• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //! Generated by `sourcegen_ast`, do not edit by hand.
2 
3 #![allow(non_snake_case)]
4 use crate::{
5     ast::{self, support, AstChildren, AstNode},
6     SyntaxKind::{self, *},
7     SyntaxNode, SyntaxToken, T,
8 };
9 
10 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
11 pub struct Name {
12     pub(crate) syntax: SyntaxNode,
13 }
14 impl Name {
ident_token(&self) -> Option<SyntaxToken>15     pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
self_token(&self) -> Option<SyntaxToken>16     pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
17 }
18 
19 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
20 pub struct NameRef {
21     pub(crate) syntax: SyntaxNode,
22 }
23 impl NameRef {
ident_token(&self) -> Option<SyntaxToken>24     pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
self_token(&self) -> Option<SyntaxToken>25     pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
super_token(&self) -> Option<SyntaxToken>26     pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }
crate_token(&self) -> Option<SyntaxToken>27     pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
Self_token(&self) -> Option<SyntaxToken>28     pub fn Self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![Self]) }
29 }
30 
31 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
32 pub struct Lifetime {
33     pub(crate) syntax: SyntaxNode,
34 }
35 impl Lifetime {
lifetime_ident_token(&self) -> Option<SyntaxToken>36     pub fn lifetime_ident_token(&self) -> Option<SyntaxToken> {
37         support::token(&self.syntax, T![lifetime_ident])
38     }
39 }
40 
41 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
42 pub struct Path {
43     pub(crate) syntax: SyntaxNode,
44 }
45 impl Path {
qualifier(&self) -> Option<Path>46     pub fn qualifier(&self) -> Option<Path> { support::child(&self.syntax) }
coloncolon_token(&self) -> Option<SyntaxToken>47     pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
segment(&self) -> Option<PathSegment>48     pub fn segment(&self) -> Option<PathSegment> { support::child(&self.syntax) }
49 }
50 
51 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
52 pub struct PathSegment {
53     pub(crate) syntax: SyntaxNode,
54 }
55 impl PathSegment {
coloncolon_token(&self) -> Option<SyntaxToken>56     pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
name_ref(&self) -> Option<NameRef>57     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
generic_arg_list(&self) -> Option<GenericArgList>58     pub fn generic_arg_list(&self) -> Option<GenericArgList> { support::child(&self.syntax) }
param_list(&self) -> Option<ParamList>59     pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
ret_type(&self) -> Option<RetType>60     pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
l_angle_token(&self) -> Option<SyntaxToken>61     pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
path_type(&self) -> Option<PathType>62     pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) }
as_token(&self) -> Option<SyntaxToken>63     pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
r_angle_token(&self) -> Option<SyntaxToken>64     pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
65 }
66 
67 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
68 pub struct GenericArgList {
69     pub(crate) syntax: SyntaxNode,
70 }
71 impl GenericArgList {
coloncolon_token(&self) -> Option<SyntaxToken>72     pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
l_angle_token(&self) -> Option<SyntaxToken>73     pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
generic_args(&self) -> AstChildren<GenericArg>74     pub fn generic_args(&self) -> AstChildren<GenericArg> { support::children(&self.syntax) }
r_angle_token(&self) -> Option<SyntaxToken>75     pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
76 }
77 
78 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
79 pub struct ParamList {
80     pub(crate) syntax: SyntaxNode,
81 }
82 impl ParamList {
l_paren_token(&self) -> Option<SyntaxToken>83     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
self_param(&self) -> Option<SelfParam>84     pub fn self_param(&self) -> Option<SelfParam> { support::child(&self.syntax) }
comma_token(&self) -> Option<SyntaxToken>85     pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
params(&self) -> AstChildren<Param>86     pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) }
r_paren_token(&self) -> Option<SyntaxToken>87     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
pipe_token(&self) -> Option<SyntaxToken>88     pub fn pipe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![|]) }
89 }
90 
91 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
92 pub struct RetType {
93     pub(crate) syntax: SyntaxNode,
94 }
95 impl RetType {
thin_arrow_token(&self) -> Option<SyntaxToken>96     pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) }
ty(&self) -> Option<Type>97     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
98 }
99 
100 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
101 pub struct PathType {
102     pub(crate) syntax: SyntaxNode,
103 }
104 impl PathType {
path(&self) -> Option<Path>105     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
106 }
107 
108 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
109 pub struct TypeArg {
110     pub(crate) syntax: SyntaxNode,
111 }
112 impl TypeArg {
ty(&self) -> Option<Type>113     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
114 }
115 
116 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
117 pub struct AssocTypeArg {
118     pub(crate) syntax: SyntaxNode,
119 }
120 impl ast::HasTypeBounds for AssocTypeArg {}
121 impl AssocTypeArg {
name_ref(&self) -> Option<NameRef>122     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
generic_arg_list(&self) -> Option<GenericArgList>123     pub fn generic_arg_list(&self) -> Option<GenericArgList> { support::child(&self.syntax) }
param_list(&self) -> Option<ParamList>124     pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
ret_type(&self) -> Option<RetType>125     pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
eq_token(&self) -> Option<SyntaxToken>126     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
ty(&self) -> Option<Type>127     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
const_arg(&self) -> Option<ConstArg>128     pub fn const_arg(&self) -> Option<ConstArg> { support::child(&self.syntax) }
129 }
130 
131 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
132 pub struct LifetimeArg {
133     pub(crate) syntax: SyntaxNode,
134 }
135 impl LifetimeArg {
lifetime(&self) -> Option<Lifetime>136     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
137 }
138 
139 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
140 pub struct ConstArg {
141     pub(crate) syntax: SyntaxNode,
142 }
143 impl ConstArg {
expr(&self) -> Option<Expr>144     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
145 }
146 
147 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
148 pub struct TypeBoundList {
149     pub(crate) syntax: SyntaxNode,
150 }
151 impl TypeBoundList {
bounds(&self) -> AstChildren<TypeBound>152     pub fn bounds(&self) -> AstChildren<TypeBound> { support::children(&self.syntax) }
153 }
154 
155 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
156 pub struct MacroCall {
157     pub(crate) syntax: SyntaxNode,
158 }
159 impl ast::HasAttrs for MacroCall {}
160 impl ast::HasDocComments for MacroCall {}
161 impl MacroCall {
path(&self) -> Option<Path>162     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
excl_token(&self) -> Option<SyntaxToken>163     pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
token_tree(&self) -> Option<TokenTree>164     pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
semicolon_token(&self) -> Option<SyntaxToken>165     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
166 }
167 
168 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
169 pub struct Attr {
170     pub(crate) syntax: SyntaxNode,
171 }
172 impl Attr {
pound_token(&self) -> Option<SyntaxToken>173     pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
excl_token(&self) -> Option<SyntaxToken>174     pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
l_brack_token(&self) -> Option<SyntaxToken>175     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
meta(&self) -> Option<Meta>176     pub fn meta(&self) -> Option<Meta> { support::child(&self.syntax) }
r_brack_token(&self) -> Option<SyntaxToken>177     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
178 }
179 
180 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
181 pub struct TokenTree {
182     pub(crate) syntax: SyntaxNode,
183 }
184 impl TokenTree {
l_paren_token(&self) -> Option<SyntaxToken>185     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
r_paren_token(&self) -> Option<SyntaxToken>186     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
l_curly_token(&self) -> Option<SyntaxToken>187     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
r_curly_token(&self) -> Option<SyntaxToken>188     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
l_brack_token(&self) -> Option<SyntaxToken>189     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
r_brack_token(&self) -> Option<SyntaxToken>190     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
191 }
192 
193 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
194 pub struct MacroItems {
195     pub(crate) syntax: SyntaxNode,
196 }
197 impl ast::HasModuleItem for MacroItems {}
198 impl MacroItems {}
199 
200 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
201 pub struct MacroStmts {
202     pub(crate) syntax: SyntaxNode,
203 }
204 impl MacroStmts {
statements(&self) -> AstChildren<Stmt>205     pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
expr(&self) -> Option<Expr>206     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
207 }
208 
209 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
210 pub struct SourceFile {
211     pub(crate) syntax: SyntaxNode,
212 }
213 impl ast::HasAttrs for SourceFile {}
214 impl ast::HasModuleItem for SourceFile {}
215 impl ast::HasDocComments for SourceFile {}
216 impl SourceFile {
shebang_token(&self) -> Option<SyntaxToken>217     pub fn shebang_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![shebang]) }
218 }
219 
220 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
221 pub struct Const {
222     pub(crate) syntax: SyntaxNode,
223 }
224 impl ast::HasAttrs for Const {}
225 impl ast::HasName for Const {}
226 impl ast::HasVisibility for Const {}
227 impl ast::HasDocComments for Const {}
228 impl Const {
default_token(&self) -> Option<SyntaxToken>229     pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
const_token(&self) -> Option<SyntaxToken>230     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
underscore_token(&self) -> Option<SyntaxToken>231     pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
colon_token(&self) -> Option<SyntaxToken>232     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
ty(&self) -> Option<Type>233     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
eq_token(&self) -> Option<SyntaxToken>234     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
body(&self) -> Option<Expr>235     pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
semicolon_token(&self) -> Option<SyntaxToken>236     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
237 }
238 
239 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
240 pub struct Enum {
241     pub(crate) syntax: SyntaxNode,
242 }
243 impl ast::HasAttrs for Enum {}
244 impl ast::HasName for Enum {}
245 impl ast::HasVisibility for Enum {}
246 impl ast::HasGenericParams for Enum {}
247 impl ast::HasDocComments for Enum {}
248 impl Enum {
enum_token(&self) -> Option<SyntaxToken>249     pub fn enum_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![enum]) }
variant_list(&self) -> Option<VariantList>250     pub fn variant_list(&self) -> Option<VariantList> { support::child(&self.syntax) }
251 }
252 
253 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
254 pub struct ExternBlock {
255     pub(crate) syntax: SyntaxNode,
256 }
257 impl ast::HasAttrs for ExternBlock {}
258 impl ast::HasDocComments for ExternBlock {}
259 impl ExternBlock {
unsafe_token(&self) -> Option<SyntaxToken>260     pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
abi(&self) -> Option<Abi>261     pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
extern_item_list(&self) -> Option<ExternItemList>262     pub fn extern_item_list(&self) -> Option<ExternItemList> { support::child(&self.syntax) }
263 }
264 
265 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
266 pub struct ExternCrate {
267     pub(crate) syntax: SyntaxNode,
268 }
269 impl ast::HasAttrs for ExternCrate {}
270 impl ast::HasVisibility for ExternCrate {}
271 impl ast::HasDocComments for ExternCrate {}
272 impl ExternCrate {
extern_token(&self) -> Option<SyntaxToken>273     pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }
crate_token(&self) -> Option<SyntaxToken>274     pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
name_ref(&self) -> Option<NameRef>275     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
rename(&self) -> Option<Rename>276     pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) }
semicolon_token(&self) -> Option<SyntaxToken>277     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
278 }
279 
280 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
281 pub struct Fn {
282     pub(crate) syntax: SyntaxNode,
283 }
284 impl ast::HasAttrs for Fn {}
285 impl ast::HasName for Fn {}
286 impl ast::HasVisibility for Fn {}
287 impl ast::HasGenericParams for Fn {}
288 impl ast::HasDocComments for Fn {}
289 impl Fn {
default_token(&self) -> Option<SyntaxToken>290     pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
const_token(&self) -> Option<SyntaxToken>291     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
async_token(&self) -> Option<SyntaxToken>292     pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
unsafe_token(&self) -> Option<SyntaxToken>293     pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
abi(&self) -> Option<Abi>294     pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
fn_token(&self) -> Option<SyntaxToken>295     pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) }
param_list(&self) -> Option<ParamList>296     pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
ret_type(&self) -> Option<RetType>297     pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
body(&self) -> Option<BlockExpr>298     pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
semicolon_token(&self) -> Option<SyntaxToken>299     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
300 }
301 
302 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
303 pub struct Impl {
304     pub(crate) syntax: SyntaxNode,
305 }
306 impl ast::HasAttrs for Impl {}
307 impl ast::HasVisibility for Impl {}
308 impl ast::HasGenericParams for Impl {}
309 impl ast::HasDocComments for Impl {}
310 impl Impl {
default_token(&self) -> Option<SyntaxToken>311     pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
unsafe_token(&self) -> Option<SyntaxToken>312     pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
impl_token(&self) -> Option<SyntaxToken>313     pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
const_token(&self) -> Option<SyntaxToken>314     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
excl_token(&self) -> Option<SyntaxToken>315     pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
for_token(&self) -> Option<SyntaxToken>316     pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
assoc_item_list(&self) -> Option<AssocItemList>317     pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }
318 }
319 
320 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
321 pub struct MacroRules {
322     pub(crate) syntax: SyntaxNode,
323 }
324 impl ast::HasAttrs for MacroRules {}
325 impl ast::HasName for MacroRules {}
326 impl ast::HasVisibility for MacroRules {}
327 impl ast::HasDocComments for MacroRules {}
328 impl MacroRules {
macro_rules_token(&self) -> Option<SyntaxToken>329     pub fn macro_rules_token(&self) -> Option<SyntaxToken> {
330         support::token(&self.syntax, T![macro_rules])
331     }
excl_token(&self) -> Option<SyntaxToken>332     pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
token_tree(&self) -> Option<TokenTree>333     pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
334 }
335 
336 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
337 pub struct MacroDef {
338     pub(crate) syntax: SyntaxNode,
339 }
340 impl ast::HasAttrs for MacroDef {}
341 impl ast::HasName for MacroDef {}
342 impl ast::HasVisibility for MacroDef {}
343 impl ast::HasDocComments for MacroDef {}
344 impl MacroDef {
macro_token(&self) -> Option<SyntaxToken>345     pub fn macro_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![macro]) }
args(&self) -> Option<TokenTree>346     pub fn args(&self) -> Option<TokenTree> { support::child(&self.syntax) }
body(&self) -> Option<TokenTree>347     pub fn body(&self) -> Option<TokenTree> { support::child(&self.syntax) }
348 }
349 
350 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
351 pub struct Module {
352     pub(crate) syntax: SyntaxNode,
353 }
354 impl ast::HasAttrs for Module {}
355 impl ast::HasName for Module {}
356 impl ast::HasVisibility for Module {}
357 impl ast::HasDocComments for Module {}
358 impl Module {
mod_token(&self) -> Option<SyntaxToken>359     pub fn mod_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mod]) }
item_list(&self) -> Option<ItemList>360     pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
semicolon_token(&self) -> Option<SyntaxToken>361     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
362 }
363 
364 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
365 pub struct Static {
366     pub(crate) syntax: SyntaxNode,
367 }
368 impl ast::HasAttrs for Static {}
369 impl ast::HasName for Static {}
370 impl ast::HasVisibility for Static {}
371 impl ast::HasDocComments for Static {}
372 impl Static {
static_token(&self) -> Option<SyntaxToken>373     pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) }
mut_token(&self) -> Option<SyntaxToken>374     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
colon_token(&self) -> Option<SyntaxToken>375     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
ty(&self) -> Option<Type>376     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
eq_token(&self) -> Option<SyntaxToken>377     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
body(&self) -> Option<Expr>378     pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
semicolon_token(&self) -> Option<SyntaxToken>379     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
380 }
381 
382 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
383 pub struct Struct {
384     pub(crate) syntax: SyntaxNode,
385 }
386 impl ast::HasAttrs for Struct {}
387 impl ast::HasName for Struct {}
388 impl ast::HasVisibility for Struct {}
389 impl ast::HasGenericParams for Struct {}
390 impl ast::HasDocComments for Struct {}
391 impl Struct {
struct_token(&self) -> Option<SyntaxToken>392     pub fn struct_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![struct]) }
semicolon_token(&self) -> Option<SyntaxToken>393     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
field_list(&self) -> Option<FieldList>394     pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) }
395 }
396 
397 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
398 pub struct Trait {
399     pub(crate) syntax: SyntaxNode,
400 }
401 impl ast::HasAttrs for Trait {}
402 impl ast::HasName for Trait {}
403 impl ast::HasVisibility for Trait {}
404 impl ast::HasGenericParams for Trait {}
405 impl ast::HasTypeBounds for Trait {}
406 impl ast::HasDocComments for Trait {}
407 impl Trait {
unsafe_token(&self) -> Option<SyntaxToken>408     pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
auto_token(&self) -> Option<SyntaxToken>409     pub fn auto_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![auto]) }
trait_token(&self) -> Option<SyntaxToken>410     pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) }
assoc_item_list(&self) -> Option<AssocItemList>411     pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }
412 }
413 
414 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
415 pub struct TraitAlias {
416     pub(crate) syntax: SyntaxNode,
417 }
418 impl ast::HasAttrs for TraitAlias {}
419 impl ast::HasName for TraitAlias {}
420 impl ast::HasVisibility for TraitAlias {}
421 impl ast::HasGenericParams for TraitAlias {}
422 impl ast::HasDocComments for TraitAlias {}
423 impl TraitAlias {
trait_token(&self) -> Option<SyntaxToken>424     pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) }
eq_token(&self) -> Option<SyntaxToken>425     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
type_bound_list(&self) -> Option<TypeBoundList>426     pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }
semicolon_token(&self) -> Option<SyntaxToken>427     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
428 }
429 
430 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
431 pub struct TypeAlias {
432     pub(crate) syntax: SyntaxNode,
433 }
434 impl ast::HasAttrs for TypeAlias {}
435 impl ast::HasName for TypeAlias {}
436 impl ast::HasVisibility for TypeAlias {}
437 impl ast::HasGenericParams for TypeAlias {}
438 impl ast::HasTypeBounds for TypeAlias {}
439 impl ast::HasDocComments for TypeAlias {}
440 impl TypeAlias {
default_token(&self) -> Option<SyntaxToken>441     pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
type_token(&self) -> Option<SyntaxToken>442     pub fn type_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![type]) }
eq_token(&self) -> Option<SyntaxToken>443     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
ty(&self) -> Option<Type>444     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
semicolon_token(&self) -> Option<SyntaxToken>445     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
446 }
447 
448 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
449 pub struct Union {
450     pub(crate) syntax: SyntaxNode,
451 }
452 impl ast::HasAttrs for Union {}
453 impl ast::HasName for Union {}
454 impl ast::HasVisibility for Union {}
455 impl ast::HasGenericParams for Union {}
456 impl ast::HasDocComments for Union {}
457 impl Union {
union_token(&self) -> Option<SyntaxToken>458     pub fn union_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![union]) }
record_field_list(&self) -> Option<RecordFieldList>459     pub fn record_field_list(&self) -> Option<RecordFieldList> { support::child(&self.syntax) }
460 }
461 
462 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
463 pub struct Use {
464     pub(crate) syntax: SyntaxNode,
465 }
466 impl ast::HasAttrs for Use {}
467 impl ast::HasVisibility for Use {}
468 impl ast::HasDocComments for Use {}
469 impl Use {
use_token(&self) -> Option<SyntaxToken>470     pub fn use_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![use]) }
use_tree(&self) -> Option<UseTree>471     pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) }
semicolon_token(&self) -> Option<SyntaxToken>472     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
473 }
474 
475 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
476 pub struct Visibility {
477     pub(crate) syntax: SyntaxNode,
478 }
479 impl Visibility {
pub_token(&self) -> Option<SyntaxToken>480     pub fn pub_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![pub]) }
l_paren_token(&self) -> Option<SyntaxToken>481     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
in_token(&self) -> Option<SyntaxToken>482     pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
path(&self) -> Option<Path>483     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
r_paren_token(&self) -> Option<SyntaxToken>484     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
485 }
486 
487 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
488 pub struct ItemList {
489     pub(crate) syntax: SyntaxNode,
490 }
491 impl ast::HasAttrs for ItemList {}
492 impl ast::HasModuleItem for ItemList {}
493 impl ItemList {
l_curly_token(&self) -> Option<SyntaxToken>494     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
r_curly_token(&self) -> Option<SyntaxToken>495     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
496 }
497 
498 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
499 pub struct Rename {
500     pub(crate) syntax: SyntaxNode,
501 }
502 impl ast::HasName for Rename {}
503 impl Rename {
as_token(&self) -> Option<SyntaxToken>504     pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
underscore_token(&self) -> Option<SyntaxToken>505     pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
506 }
507 
508 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
509 pub struct UseTree {
510     pub(crate) syntax: SyntaxNode,
511 }
512 impl UseTree {
path(&self) -> Option<Path>513     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
coloncolon_token(&self) -> Option<SyntaxToken>514     pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
star_token(&self) -> Option<SyntaxToken>515     pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
use_tree_list(&self) -> Option<UseTreeList>516     pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) }
rename(&self) -> Option<Rename>517     pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) }
518 }
519 
520 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
521 pub struct UseTreeList {
522     pub(crate) syntax: SyntaxNode,
523 }
524 impl UseTreeList {
l_curly_token(&self) -> Option<SyntaxToken>525     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
use_trees(&self) -> AstChildren<UseTree>526     pub fn use_trees(&self) -> AstChildren<UseTree> { support::children(&self.syntax) }
r_curly_token(&self) -> Option<SyntaxToken>527     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
528 }
529 
530 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
531 pub struct Abi {
532     pub(crate) syntax: SyntaxNode,
533 }
534 impl Abi {
extern_token(&self) -> Option<SyntaxToken>535     pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }
536 }
537 
538 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
539 pub struct GenericParamList {
540     pub(crate) syntax: SyntaxNode,
541 }
542 impl GenericParamList {
l_angle_token(&self) -> Option<SyntaxToken>543     pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
generic_params(&self) -> AstChildren<GenericParam>544     pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) }
r_angle_token(&self) -> Option<SyntaxToken>545     pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
546 }
547 
548 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
549 pub struct WhereClause {
550     pub(crate) syntax: SyntaxNode,
551 }
552 impl WhereClause {
where_token(&self) -> Option<SyntaxToken>553     pub fn where_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![where]) }
predicates(&self) -> AstChildren<WherePred>554     pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) }
555 }
556 
557 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
558 pub struct BlockExpr {
559     pub(crate) syntax: SyntaxNode,
560 }
561 impl ast::HasAttrs for BlockExpr {}
562 impl BlockExpr {
label(&self) -> Option<Label>563     pub fn label(&self) -> Option<Label> { support::child(&self.syntax) }
try_token(&self) -> Option<SyntaxToken>564     pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) }
unsafe_token(&self) -> Option<SyntaxToken>565     pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
async_token(&self) -> Option<SyntaxToken>566     pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
const_token(&self) -> Option<SyntaxToken>567     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
stmt_list(&self) -> Option<StmtList>568     pub fn stmt_list(&self) -> Option<StmtList> { support::child(&self.syntax) }
569 }
570 
571 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
572 pub struct SelfParam {
573     pub(crate) syntax: SyntaxNode,
574 }
575 impl ast::HasAttrs for SelfParam {}
576 impl ast::HasName for SelfParam {}
577 impl SelfParam {
amp_token(&self) -> Option<SyntaxToken>578     pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
lifetime(&self) -> Option<Lifetime>579     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
mut_token(&self) -> Option<SyntaxToken>580     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
colon_token(&self) -> Option<SyntaxToken>581     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
ty(&self) -> Option<Type>582     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
583 }
584 
585 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
586 pub struct Param {
587     pub(crate) syntax: SyntaxNode,
588 }
589 impl ast::HasAttrs for Param {}
590 impl Param {
pat(&self) -> Option<Pat>591     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
colon_token(&self) -> Option<SyntaxToken>592     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
ty(&self) -> Option<Type>593     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
dotdotdot_token(&self) -> Option<SyntaxToken>594     pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) }
595 }
596 
597 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
598 pub struct RecordFieldList {
599     pub(crate) syntax: SyntaxNode,
600 }
601 impl RecordFieldList {
l_curly_token(&self) -> Option<SyntaxToken>602     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
fields(&self) -> AstChildren<RecordField>603     pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) }
r_curly_token(&self) -> Option<SyntaxToken>604     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
605 }
606 
607 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
608 pub struct TupleFieldList {
609     pub(crate) syntax: SyntaxNode,
610 }
611 impl TupleFieldList {
l_paren_token(&self) -> Option<SyntaxToken>612     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
fields(&self) -> AstChildren<TupleField>613     pub fn fields(&self) -> AstChildren<TupleField> { support::children(&self.syntax) }
r_paren_token(&self) -> Option<SyntaxToken>614     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
615 }
616 
617 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
618 pub struct RecordField {
619     pub(crate) syntax: SyntaxNode,
620 }
621 impl ast::HasAttrs for RecordField {}
622 impl ast::HasName for RecordField {}
623 impl ast::HasVisibility for RecordField {}
624 impl ast::HasDocComments for RecordField {}
625 impl RecordField {
colon_token(&self) -> Option<SyntaxToken>626     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
ty(&self) -> Option<Type>627     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
628 }
629 
630 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
631 pub struct TupleField {
632     pub(crate) syntax: SyntaxNode,
633 }
634 impl ast::HasAttrs for TupleField {}
635 impl ast::HasVisibility for TupleField {}
636 impl ast::HasDocComments for TupleField {}
637 impl TupleField {
ty(&self) -> Option<Type>638     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
639 }
640 
641 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
642 pub struct VariantList {
643     pub(crate) syntax: SyntaxNode,
644 }
645 impl VariantList {
l_curly_token(&self) -> Option<SyntaxToken>646     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
variants(&self) -> AstChildren<Variant>647     pub fn variants(&self) -> AstChildren<Variant> { support::children(&self.syntax) }
r_curly_token(&self) -> Option<SyntaxToken>648     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
649 }
650 
651 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
652 pub struct Variant {
653     pub(crate) syntax: SyntaxNode,
654 }
655 impl ast::HasAttrs for Variant {}
656 impl ast::HasName for Variant {}
657 impl ast::HasVisibility for Variant {}
658 impl ast::HasDocComments for Variant {}
659 impl Variant {
field_list(&self) -> Option<FieldList>660     pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) }
eq_token(&self) -> Option<SyntaxToken>661     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
expr(&self) -> Option<Expr>662     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
663 }
664 
665 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
666 pub struct AssocItemList {
667     pub(crate) syntax: SyntaxNode,
668 }
669 impl ast::HasAttrs for AssocItemList {}
670 impl AssocItemList {
l_curly_token(&self) -> Option<SyntaxToken>671     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
assoc_items(&self) -> AstChildren<AssocItem>672     pub fn assoc_items(&self) -> AstChildren<AssocItem> { support::children(&self.syntax) }
r_curly_token(&self) -> Option<SyntaxToken>673     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
674 }
675 
676 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
677 pub struct ExternItemList {
678     pub(crate) syntax: SyntaxNode,
679 }
680 impl ast::HasAttrs for ExternItemList {}
681 impl ExternItemList {
l_curly_token(&self) -> Option<SyntaxToken>682     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
extern_items(&self) -> AstChildren<ExternItem>683     pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) }
r_curly_token(&self) -> Option<SyntaxToken>684     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
685 }
686 
687 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
688 pub struct ConstParam {
689     pub(crate) syntax: SyntaxNode,
690 }
691 impl ast::HasAttrs for ConstParam {}
692 impl ast::HasName for ConstParam {}
693 impl ConstParam {
const_token(&self) -> Option<SyntaxToken>694     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
colon_token(&self) -> Option<SyntaxToken>695     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
ty(&self) -> Option<Type>696     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
eq_token(&self) -> Option<SyntaxToken>697     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
default_val(&self) -> Option<Expr>698     pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) }
699 }
700 
701 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
702 pub struct LifetimeParam {
703     pub(crate) syntax: SyntaxNode,
704 }
705 impl ast::HasAttrs for LifetimeParam {}
706 impl ast::HasTypeBounds for LifetimeParam {}
707 impl LifetimeParam {
lifetime(&self) -> Option<Lifetime>708     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
709 }
710 
711 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
712 pub struct TypeParam {
713     pub(crate) syntax: SyntaxNode,
714 }
715 impl ast::HasAttrs for TypeParam {}
716 impl ast::HasName for TypeParam {}
717 impl ast::HasTypeBounds for TypeParam {}
718 impl TypeParam {
eq_token(&self) -> Option<SyntaxToken>719     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
default_type(&self) -> Option<Type>720     pub fn default_type(&self) -> Option<Type> { support::child(&self.syntax) }
721 }
722 
723 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
724 pub struct WherePred {
725     pub(crate) syntax: SyntaxNode,
726 }
727 impl ast::HasTypeBounds for WherePred {}
728 impl WherePred {
for_token(&self) -> Option<SyntaxToken>729     pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
generic_param_list(&self) -> Option<GenericParamList>730     pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) }
lifetime(&self) -> Option<Lifetime>731     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
ty(&self) -> Option<Type>732     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
733 }
734 
735 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
736 pub struct Meta {
737     pub(crate) syntax: SyntaxNode,
738 }
739 impl Meta {
path(&self) -> Option<Path>740     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
eq_token(&self) -> Option<SyntaxToken>741     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
expr(&self) -> Option<Expr>742     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
token_tree(&self) -> Option<TokenTree>743     pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
744 }
745 
746 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
747 pub struct ExprStmt {
748     pub(crate) syntax: SyntaxNode,
749 }
750 impl ExprStmt {
expr(&self) -> Option<Expr>751     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
semicolon_token(&self) -> Option<SyntaxToken>752     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
753 }
754 
755 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
756 pub struct LetStmt {
757     pub(crate) syntax: SyntaxNode,
758 }
759 impl ast::HasAttrs for LetStmt {}
760 impl LetStmt {
let_token(&self) -> Option<SyntaxToken>761     pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }
pat(&self) -> Option<Pat>762     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
colon_token(&self) -> Option<SyntaxToken>763     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
ty(&self) -> Option<Type>764     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
eq_token(&self) -> Option<SyntaxToken>765     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
initializer(&self) -> Option<Expr>766     pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) }
let_else(&self) -> Option<LetElse>767     pub fn let_else(&self) -> Option<LetElse> { support::child(&self.syntax) }
semicolon_token(&self) -> Option<SyntaxToken>768     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
769 }
770 
771 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
772 pub struct LetElse {
773     pub(crate) syntax: SyntaxNode,
774 }
775 impl LetElse {
else_token(&self) -> Option<SyntaxToken>776     pub fn else_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![else]) }
block_expr(&self) -> Option<BlockExpr>777     pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
778 }
779 
780 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
781 pub struct ArrayExpr {
782     pub(crate) syntax: SyntaxNode,
783 }
784 impl ast::HasAttrs for ArrayExpr {}
785 impl ArrayExpr {
l_brack_token(&self) -> Option<SyntaxToken>786     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
exprs(&self) -> AstChildren<Expr>787     pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
expr(&self) -> Option<Expr>788     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
semicolon_token(&self) -> Option<SyntaxToken>789     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
r_brack_token(&self) -> Option<SyntaxToken>790     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
791 }
792 
793 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
794 pub struct AwaitExpr {
795     pub(crate) syntax: SyntaxNode,
796 }
797 impl ast::HasAttrs for AwaitExpr {}
798 impl AwaitExpr {
expr(&self) -> Option<Expr>799     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
dot_token(&self) -> Option<SyntaxToken>800     pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
await_token(&self) -> Option<SyntaxToken>801     pub fn await_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![await]) }
802 }
803 
804 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
805 pub struct BinExpr {
806     pub(crate) syntax: SyntaxNode,
807 }
808 impl ast::HasAttrs for BinExpr {}
809 impl BinExpr {}
810 
811 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
812 pub struct BoxExpr {
813     pub(crate) syntax: SyntaxNode,
814 }
815 impl ast::HasAttrs for BoxExpr {}
816 impl BoxExpr {
box_token(&self) -> Option<SyntaxToken>817     pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) }
expr(&self) -> Option<Expr>818     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
819 }
820 
821 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
822 pub struct BreakExpr {
823     pub(crate) syntax: SyntaxNode,
824 }
825 impl ast::HasAttrs for BreakExpr {}
826 impl BreakExpr {
break_token(&self) -> Option<SyntaxToken>827     pub fn break_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![break]) }
lifetime(&self) -> Option<Lifetime>828     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
expr(&self) -> Option<Expr>829     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
830 }
831 
832 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
833 pub struct CallExpr {
834     pub(crate) syntax: SyntaxNode,
835 }
836 impl ast::HasAttrs for CallExpr {}
837 impl ast::HasArgList for CallExpr {}
838 impl CallExpr {
expr(&self) -> Option<Expr>839     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
840 }
841 
842 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
843 pub struct CastExpr {
844     pub(crate) syntax: SyntaxNode,
845 }
846 impl ast::HasAttrs for CastExpr {}
847 impl CastExpr {
expr(&self) -> Option<Expr>848     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
as_token(&self) -> Option<SyntaxToken>849     pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
ty(&self) -> Option<Type>850     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
851 }
852 
853 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
854 pub struct ClosureExpr {
855     pub(crate) syntax: SyntaxNode,
856 }
857 impl ast::HasAttrs for ClosureExpr {}
858 impl ClosureExpr {
for_token(&self) -> Option<SyntaxToken>859     pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
generic_param_list(&self) -> Option<GenericParamList>860     pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) }
const_token(&self) -> Option<SyntaxToken>861     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
static_token(&self) -> Option<SyntaxToken>862     pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) }
async_token(&self) -> Option<SyntaxToken>863     pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
move_token(&self) -> Option<SyntaxToken>864     pub fn move_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![move]) }
param_list(&self) -> Option<ParamList>865     pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
ret_type(&self) -> Option<RetType>866     pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
body(&self) -> Option<Expr>867     pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
868 }
869 
870 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
871 pub struct ContinueExpr {
872     pub(crate) syntax: SyntaxNode,
873 }
874 impl ast::HasAttrs for ContinueExpr {}
875 impl ContinueExpr {
continue_token(&self) -> Option<SyntaxToken>876     pub fn continue_token(&self) -> Option<SyntaxToken> {
877         support::token(&self.syntax, T![continue])
878     }
lifetime(&self) -> Option<Lifetime>879     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
880 }
881 
882 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
883 pub struct FieldExpr {
884     pub(crate) syntax: SyntaxNode,
885 }
886 impl ast::HasAttrs for FieldExpr {}
887 impl FieldExpr {
expr(&self) -> Option<Expr>888     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
dot_token(&self) -> Option<SyntaxToken>889     pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
name_ref(&self) -> Option<NameRef>890     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
891 }
892 
893 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
894 pub struct ForExpr {
895     pub(crate) syntax: SyntaxNode,
896 }
897 impl ast::HasAttrs for ForExpr {}
898 impl ForExpr {
for_token(&self) -> Option<SyntaxToken>899     pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
pat(&self) -> Option<Pat>900     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
in_token(&self) -> Option<SyntaxToken>901     pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
902 }
903 
904 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
905 pub struct IfExpr {
906     pub(crate) syntax: SyntaxNode,
907 }
908 impl ast::HasAttrs for IfExpr {}
909 impl IfExpr {
if_token(&self) -> Option<SyntaxToken>910     pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }
else_token(&self) -> Option<SyntaxToken>911     pub fn else_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![else]) }
912 }
913 
914 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
915 pub struct IndexExpr {
916     pub(crate) syntax: SyntaxNode,
917 }
918 impl ast::HasAttrs for IndexExpr {}
919 impl IndexExpr {
l_brack_token(&self) -> Option<SyntaxToken>920     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
r_brack_token(&self) -> Option<SyntaxToken>921     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
922 }
923 
924 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
925 pub struct Literal {
926     pub(crate) syntax: SyntaxNode,
927 }
928 impl ast::HasAttrs for Literal {}
929 impl Literal {}
930 
931 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
932 pub struct LoopExpr {
933     pub(crate) syntax: SyntaxNode,
934 }
935 impl ast::HasAttrs for LoopExpr {}
936 impl ast::HasLoopBody for LoopExpr {}
937 impl LoopExpr {
loop_token(&self) -> Option<SyntaxToken>938     pub fn loop_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![loop]) }
939 }
940 
941 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
942 pub struct MacroExpr {
943     pub(crate) syntax: SyntaxNode,
944 }
945 impl MacroExpr {
macro_call(&self) -> Option<MacroCall>946     pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
947 }
948 
949 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
950 pub struct MatchExpr {
951     pub(crate) syntax: SyntaxNode,
952 }
953 impl ast::HasAttrs for MatchExpr {}
954 impl MatchExpr {
match_token(&self) -> Option<SyntaxToken>955     pub fn match_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![match]) }
expr(&self) -> Option<Expr>956     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
match_arm_list(&self) -> Option<MatchArmList>957     pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) }
958 }
959 
960 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
961 pub struct MethodCallExpr {
962     pub(crate) syntax: SyntaxNode,
963 }
964 impl ast::HasAttrs for MethodCallExpr {}
965 impl ast::HasArgList for MethodCallExpr {}
966 impl MethodCallExpr {
receiver(&self) -> Option<Expr>967     pub fn receiver(&self) -> Option<Expr> { support::child(&self.syntax) }
dot_token(&self) -> Option<SyntaxToken>968     pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
name_ref(&self) -> Option<NameRef>969     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
generic_arg_list(&self) -> Option<GenericArgList>970     pub fn generic_arg_list(&self) -> Option<GenericArgList> { support::child(&self.syntax) }
971 }
972 
973 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
974 pub struct ParenExpr {
975     pub(crate) syntax: SyntaxNode,
976 }
977 impl ast::HasAttrs for ParenExpr {}
978 impl ParenExpr {
l_paren_token(&self) -> Option<SyntaxToken>979     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
expr(&self) -> Option<Expr>980     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
r_paren_token(&self) -> Option<SyntaxToken>981     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
982 }
983 
984 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
985 pub struct PathExpr {
986     pub(crate) syntax: SyntaxNode,
987 }
988 impl ast::HasAttrs for PathExpr {}
989 impl PathExpr {
path(&self) -> Option<Path>990     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
991 }
992 
993 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
994 pub struct PrefixExpr {
995     pub(crate) syntax: SyntaxNode,
996 }
997 impl ast::HasAttrs for PrefixExpr {}
998 impl PrefixExpr {
expr(&self) -> Option<Expr>999     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1000 }
1001 
1002 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1003 pub struct RangeExpr {
1004     pub(crate) syntax: SyntaxNode,
1005 }
1006 impl ast::HasAttrs for RangeExpr {}
1007 impl RangeExpr {}
1008 
1009 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1010 pub struct RecordExpr {
1011     pub(crate) syntax: SyntaxNode,
1012 }
1013 impl RecordExpr {
path(&self) -> Option<Path>1014     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
record_expr_field_list(&self) -> Option<RecordExprFieldList>1015     pub fn record_expr_field_list(&self) -> Option<RecordExprFieldList> {
1016         support::child(&self.syntax)
1017     }
1018 }
1019 
1020 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1021 pub struct RefExpr {
1022     pub(crate) syntax: SyntaxNode,
1023 }
1024 impl ast::HasAttrs for RefExpr {}
1025 impl RefExpr {
amp_token(&self) -> Option<SyntaxToken>1026     pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
raw_token(&self) -> Option<SyntaxToken>1027     pub fn raw_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![raw]) }
mut_token(&self) -> Option<SyntaxToken>1028     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
const_token(&self) -> Option<SyntaxToken>1029     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
expr(&self) -> Option<Expr>1030     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1031 }
1032 
1033 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1034 pub struct ReturnExpr {
1035     pub(crate) syntax: SyntaxNode,
1036 }
1037 impl ast::HasAttrs for ReturnExpr {}
1038 impl ReturnExpr {
return_token(&self) -> Option<SyntaxToken>1039     pub fn return_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![return]) }
expr(&self) -> Option<Expr>1040     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1041 }
1042 
1043 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1044 pub struct TryExpr {
1045     pub(crate) syntax: SyntaxNode,
1046 }
1047 impl ast::HasAttrs for TryExpr {}
1048 impl TryExpr {
expr(&self) -> Option<Expr>1049     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
question_mark_token(&self) -> Option<SyntaxToken>1050     pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }
1051 }
1052 
1053 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1054 pub struct TupleExpr {
1055     pub(crate) syntax: SyntaxNode,
1056 }
1057 impl ast::HasAttrs for TupleExpr {}
1058 impl TupleExpr {
l_paren_token(&self) -> Option<SyntaxToken>1059     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
fields(&self) -> AstChildren<Expr>1060     pub fn fields(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
r_paren_token(&self) -> Option<SyntaxToken>1061     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1062 }
1063 
1064 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1065 pub struct WhileExpr {
1066     pub(crate) syntax: SyntaxNode,
1067 }
1068 impl ast::HasAttrs for WhileExpr {}
1069 impl WhileExpr {
while_token(&self) -> Option<SyntaxToken>1070     pub fn while_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![while]) }
1071 }
1072 
1073 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1074 pub struct YieldExpr {
1075     pub(crate) syntax: SyntaxNode,
1076 }
1077 impl ast::HasAttrs for YieldExpr {}
1078 impl YieldExpr {
yield_token(&self) -> Option<SyntaxToken>1079     pub fn yield_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![yield]) }
expr(&self) -> Option<Expr>1080     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1081 }
1082 
1083 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1084 pub struct YeetExpr {
1085     pub(crate) syntax: SyntaxNode,
1086 }
1087 impl ast::HasAttrs for YeetExpr {}
1088 impl YeetExpr {
do_token(&self) -> Option<SyntaxToken>1089     pub fn do_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![do]) }
yeet_token(&self) -> Option<SyntaxToken>1090     pub fn yeet_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![yeet]) }
expr(&self) -> Option<Expr>1091     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1092 }
1093 
1094 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1095 pub struct LetExpr {
1096     pub(crate) syntax: SyntaxNode,
1097 }
1098 impl ast::HasAttrs for LetExpr {}
1099 impl LetExpr {
let_token(&self) -> Option<SyntaxToken>1100     pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }
pat(&self) -> Option<Pat>1101     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
eq_token(&self) -> Option<SyntaxToken>1102     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
expr(&self) -> Option<Expr>1103     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1104 }
1105 
1106 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1107 pub struct UnderscoreExpr {
1108     pub(crate) syntax: SyntaxNode,
1109 }
1110 impl ast::HasAttrs for UnderscoreExpr {}
1111 impl UnderscoreExpr {
underscore_token(&self) -> Option<SyntaxToken>1112     pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
1113 }
1114 
1115 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1116 pub struct StmtList {
1117     pub(crate) syntax: SyntaxNode,
1118 }
1119 impl ast::HasAttrs for StmtList {}
1120 impl StmtList {
l_curly_token(&self) -> Option<SyntaxToken>1121     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
statements(&self) -> AstChildren<Stmt>1122     pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
tail_expr(&self) -> Option<Expr>1123     pub fn tail_expr(&self) -> Option<Expr> { support::child(&self.syntax) }
r_curly_token(&self) -> Option<SyntaxToken>1124     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1125 }
1126 
1127 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1128 pub struct Label {
1129     pub(crate) syntax: SyntaxNode,
1130 }
1131 impl Label {
lifetime(&self) -> Option<Lifetime>1132     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
colon_token(&self) -> Option<SyntaxToken>1133     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
1134 }
1135 
1136 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1137 pub struct RecordExprFieldList {
1138     pub(crate) syntax: SyntaxNode,
1139 }
1140 impl ast::HasAttrs for RecordExprFieldList {}
1141 impl RecordExprFieldList {
l_curly_token(&self) -> Option<SyntaxToken>1142     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
fields(&self) -> AstChildren<RecordExprField>1143     pub fn fields(&self) -> AstChildren<RecordExprField> { support::children(&self.syntax) }
dotdot_token(&self) -> Option<SyntaxToken>1144     pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
spread(&self) -> Option<Expr>1145     pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) }
r_curly_token(&self) -> Option<SyntaxToken>1146     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1147 }
1148 
1149 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1150 pub struct RecordExprField {
1151     pub(crate) syntax: SyntaxNode,
1152 }
1153 impl ast::HasAttrs for RecordExprField {}
1154 impl RecordExprField {
name_ref(&self) -> Option<NameRef>1155     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
colon_token(&self) -> Option<SyntaxToken>1156     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
expr(&self) -> Option<Expr>1157     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1158 }
1159 
1160 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1161 pub struct ArgList {
1162     pub(crate) syntax: SyntaxNode,
1163 }
1164 impl ArgList {
l_paren_token(&self) -> Option<SyntaxToken>1165     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
args(&self) -> AstChildren<Expr>1166     pub fn args(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
r_paren_token(&self) -> Option<SyntaxToken>1167     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1168 }
1169 
1170 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1171 pub struct MatchArmList {
1172     pub(crate) syntax: SyntaxNode,
1173 }
1174 impl ast::HasAttrs for MatchArmList {}
1175 impl MatchArmList {
l_curly_token(&self) -> Option<SyntaxToken>1176     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
arms(&self) -> AstChildren<MatchArm>1177     pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) }
r_curly_token(&self) -> Option<SyntaxToken>1178     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1179 }
1180 
1181 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1182 pub struct MatchArm {
1183     pub(crate) syntax: SyntaxNode,
1184 }
1185 impl ast::HasAttrs for MatchArm {}
1186 impl MatchArm {
pat(&self) -> Option<Pat>1187     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
guard(&self) -> Option<MatchGuard>1188     pub fn guard(&self) -> Option<MatchGuard> { support::child(&self.syntax) }
fat_arrow_token(&self) -> Option<SyntaxToken>1189     pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) }
expr(&self) -> Option<Expr>1190     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
comma_token(&self) -> Option<SyntaxToken>1191     pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
1192 }
1193 
1194 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1195 pub struct MatchGuard {
1196     pub(crate) syntax: SyntaxNode,
1197 }
1198 impl MatchGuard {
if_token(&self) -> Option<SyntaxToken>1199     pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }
1200 }
1201 
1202 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1203 pub struct ArrayType {
1204     pub(crate) syntax: SyntaxNode,
1205 }
1206 impl ArrayType {
l_brack_token(&self) -> Option<SyntaxToken>1207     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
ty(&self) -> Option<Type>1208     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
semicolon_token(&self) -> Option<SyntaxToken>1209     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
const_arg(&self) -> Option<ConstArg>1210     pub fn const_arg(&self) -> Option<ConstArg> { support::child(&self.syntax) }
r_brack_token(&self) -> Option<SyntaxToken>1211     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1212 }
1213 
1214 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1215 pub struct DynTraitType {
1216     pub(crate) syntax: SyntaxNode,
1217 }
1218 impl DynTraitType {
dyn_token(&self) -> Option<SyntaxToken>1219     pub fn dyn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![dyn]) }
type_bound_list(&self) -> Option<TypeBoundList>1220     pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }
1221 }
1222 
1223 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1224 pub struct FnPtrType {
1225     pub(crate) syntax: SyntaxNode,
1226 }
1227 impl FnPtrType {
const_token(&self) -> Option<SyntaxToken>1228     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
async_token(&self) -> Option<SyntaxToken>1229     pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
unsafe_token(&self) -> Option<SyntaxToken>1230     pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
abi(&self) -> Option<Abi>1231     pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
fn_token(&self) -> Option<SyntaxToken>1232     pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) }
param_list(&self) -> Option<ParamList>1233     pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
ret_type(&self) -> Option<RetType>1234     pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
1235 }
1236 
1237 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1238 pub struct ForType {
1239     pub(crate) syntax: SyntaxNode,
1240 }
1241 impl ForType {
for_token(&self) -> Option<SyntaxToken>1242     pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
generic_param_list(&self) -> Option<GenericParamList>1243     pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) }
ty(&self) -> Option<Type>1244     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1245 }
1246 
1247 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1248 pub struct ImplTraitType {
1249     pub(crate) syntax: SyntaxNode,
1250 }
1251 impl ImplTraitType {
impl_token(&self) -> Option<SyntaxToken>1252     pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
type_bound_list(&self) -> Option<TypeBoundList>1253     pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }
1254 }
1255 
1256 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1257 pub struct InferType {
1258     pub(crate) syntax: SyntaxNode,
1259 }
1260 impl InferType {
underscore_token(&self) -> Option<SyntaxToken>1261     pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
1262 }
1263 
1264 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1265 pub struct MacroType {
1266     pub(crate) syntax: SyntaxNode,
1267 }
1268 impl MacroType {
macro_call(&self) -> Option<MacroCall>1269     pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
1270 }
1271 
1272 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1273 pub struct NeverType {
1274     pub(crate) syntax: SyntaxNode,
1275 }
1276 impl NeverType {
excl_token(&self) -> Option<SyntaxToken>1277     pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
1278 }
1279 
1280 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1281 pub struct ParenType {
1282     pub(crate) syntax: SyntaxNode,
1283 }
1284 impl ParenType {
l_paren_token(&self) -> Option<SyntaxToken>1285     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
ty(&self) -> Option<Type>1286     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
r_paren_token(&self) -> Option<SyntaxToken>1287     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1288 }
1289 
1290 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1291 pub struct PtrType {
1292     pub(crate) syntax: SyntaxNode,
1293 }
1294 impl PtrType {
star_token(&self) -> Option<SyntaxToken>1295     pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
const_token(&self) -> Option<SyntaxToken>1296     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
mut_token(&self) -> Option<SyntaxToken>1297     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
ty(&self) -> Option<Type>1298     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1299 }
1300 
1301 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1302 pub struct RefType {
1303     pub(crate) syntax: SyntaxNode,
1304 }
1305 impl RefType {
amp_token(&self) -> Option<SyntaxToken>1306     pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
lifetime(&self) -> Option<Lifetime>1307     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
mut_token(&self) -> Option<SyntaxToken>1308     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
ty(&self) -> Option<Type>1309     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1310 }
1311 
1312 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1313 pub struct SliceType {
1314     pub(crate) syntax: SyntaxNode,
1315 }
1316 impl SliceType {
l_brack_token(&self) -> Option<SyntaxToken>1317     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
ty(&self) -> Option<Type>1318     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
r_brack_token(&self) -> Option<SyntaxToken>1319     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1320 }
1321 
1322 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1323 pub struct TupleType {
1324     pub(crate) syntax: SyntaxNode,
1325 }
1326 impl TupleType {
l_paren_token(&self) -> Option<SyntaxToken>1327     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
fields(&self) -> AstChildren<Type>1328     pub fn fields(&self) -> AstChildren<Type> { support::children(&self.syntax) }
r_paren_token(&self) -> Option<SyntaxToken>1329     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1330 }
1331 
1332 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1333 pub struct TypeBound {
1334     pub(crate) syntax: SyntaxNode,
1335 }
1336 impl TypeBound {
lifetime(&self) -> Option<Lifetime>1337     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
question_mark_token(&self) -> Option<SyntaxToken>1338     pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }
tilde_token(&self) -> Option<SyntaxToken>1339     pub fn tilde_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![~]) }
const_token(&self) -> Option<SyntaxToken>1340     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
ty(&self) -> Option<Type>1341     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1342 }
1343 
1344 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1345 pub struct IdentPat {
1346     pub(crate) syntax: SyntaxNode,
1347 }
1348 impl ast::HasAttrs for IdentPat {}
1349 impl ast::HasName for IdentPat {}
1350 impl IdentPat {
ref_token(&self) -> Option<SyntaxToken>1351     pub fn ref_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ref]) }
mut_token(&self) -> Option<SyntaxToken>1352     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
at_token(&self) -> Option<SyntaxToken>1353     pub fn at_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![@]) }
pat(&self) -> Option<Pat>1354     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1355 }
1356 
1357 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1358 pub struct BoxPat {
1359     pub(crate) syntax: SyntaxNode,
1360 }
1361 impl BoxPat {
box_token(&self) -> Option<SyntaxToken>1362     pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) }
pat(&self) -> Option<Pat>1363     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1364 }
1365 
1366 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1367 pub struct RestPat {
1368     pub(crate) syntax: SyntaxNode,
1369 }
1370 impl ast::HasAttrs for RestPat {}
1371 impl RestPat {
dotdot_token(&self) -> Option<SyntaxToken>1372     pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
1373 }
1374 
1375 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1376 pub struct LiteralPat {
1377     pub(crate) syntax: SyntaxNode,
1378 }
1379 impl LiteralPat {
minus_token(&self) -> Option<SyntaxToken>1380     pub fn minus_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![-]) }
literal(&self) -> Option<Literal>1381     pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
1382 }
1383 
1384 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1385 pub struct MacroPat {
1386     pub(crate) syntax: SyntaxNode,
1387 }
1388 impl MacroPat {
macro_call(&self) -> Option<MacroCall>1389     pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
1390 }
1391 
1392 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1393 pub struct OrPat {
1394     pub(crate) syntax: SyntaxNode,
1395 }
1396 impl OrPat {
pats(&self) -> AstChildren<Pat>1397     pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1398 }
1399 
1400 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1401 pub struct ParenPat {
1402     pub(crate) syntax: SyntaxNode,
1403 }
1404 impl ParenPat {
l_paren_token(&self) -> Option<SyntaxToken>1405     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
pat(&self) -> Option<Pat>1406     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
r_paren_token(&self) -> Option<SyntaxToken>1407     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1408 }
1409 
1410 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1411 pub struct PathPat {
1412     pub(crate) syntax: SyntaxNode,
1413 }
1414 impl PathPat {
path(&self) -> Option<Path>1415     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1416 }
1417 
1418 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1419 pub struct WildcardPat {
1420     pub(crate) syntax: SyntaxNode,
1421 }
1422 impl WildcardPat {
underscore_token(&self) -> Option<SyntaxToken>1423     pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
1424 }
1425 
1426 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1427 pub struct RangePat {
1428     pub(crate) syntax: SyntaxNode,
1429 }
1430 impl RangePat {}
1431 
1432 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1433 pub struct RecordPat {
1434     pub(crate) syntax: SyntaxNode,
1435 }
1436 impl RecordPat {
path(&self) -> Option<Path>1437     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
record_pat_field_list(&self) -> Option<RecordPatFieldList>1438     pub fn record_pat_field_list(&self) -> Option<RecordPatFieldList> {
1439         support::child(&self.syntax)
1440     }
1441 }
1442 
1443 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1444 pub struct RefPat {
1445     pub(crate) syntax: SyntaxNode,
1446 }
1447 impl RefPat {
amp_token(&self) -> Option<SyntaxToken>1448     pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
mut_token(&self) -> Option<SyntaxToken>1449     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
pat(&self) -> Option<Pat>1450     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1451 }
1452 
1453 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1454 pub struct SlicePat {
1455     pub(crate) syntax: SyntaxNode,
1456 }
1457 impl SlicePat {
l_brack_token(&self) -> Option<SyntaxToken>1458     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
pats(&self) -> AstChildren<Pat>1459     pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
r_brack_token(&self) -> Option<SyntaxToken>1460     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1461 }
1462 
1463 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1464 pub struct TuplePat {
1465     pub(crate) syntax: SyntaxNode,
1466 }
1467 impl TuplePat {
l_paren_token(&self) -> Option<SyntaxToken>1468     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
fields(&self) -> AstChildren<Pat>1469     pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
r_paren_token(&self) -> Option<SyntaxToken>1470     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1471 }
1472 
1473 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1474 pub struct TupleStructPat {
1475     pub(crate) syntax: SyntaxNode,
1476 }
1477 impl TupleStructPat {
path(&self) -> Option<Path>1478     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
l_paren_token(&self) -> Option<SyntaxToken>1479     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
fields(&self) -> AstChildren<Pat>1480     pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
r_paren_token(&self) -> Option<SyntaxToken>1481     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1482 }
1483 
1484 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1485 pub struct ConstBlockPat {
1486     pub(crate) syntax: SyntaxNode,
1487 }
1488 impl ConstBlockPat {
const_token(&self) -> Option<SyntaxToken>1489     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
block_expr(&self) -> Option<BlockExpr>1490     pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
1491 }
1492 
1493 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1494 pub struct RecordPatFieldList {
1495     pub(crate) syntax: SyntaxNode,
1496 }
1497 impl RecordPatFieldList {
l_curly_token(&self) -> Option<SyntaxToken>1498     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
fields(&self) -> AstChildren<RecordPatField>1499     pub fn fields(&self) -> AstChildren<RecordPatField> { support::children(&self.syntax) }
rest_pat(&self) -> Option<RestPat>1500     pub fn rest_pat(&self) -> Option<RestPat> { support::child(&self.syntax) }
r_curly_token(&self) -> Option<SyntaxToken>1501     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1502 }
1503 
1504 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1505 pub struct RecordPatField {
1506     pub(crate) syntax: SyntaxNode,
1507 }
1508 impl ast::HasAttrs for RecordPatField {}
1509 impl RecordPatField {
name_ref(&self) -> Option<NameRef>1510     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
colon_token(&self) -> Option<SyntaxToken>1511     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
pat(&self) -> Option<Pat>1512     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1513 }
1514 
1515 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1516 pub enum GenericArg {
1517     TypeArg(TypeArg),
1518     AssocTypeArg(AssocTypeArg),
1519     LifetimeArg(LifetimeArg),
1520     ConstArg(ConstArg),
1521 }
1522 
1523 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1524 pub enum Type {
1525     ArrayType(ArrayType),
1526     DynTraitType(DynTraitType),
1527     FnPtrType(FnPtrType),
1528     ForType(ForType),
1529     ImplTraitType(ImplTraitType),
1530     InferType(InferType),
1531     MacroType(MacroType),
1532     NeverType(NeverType),
1533     ParenType(ParenType),
1534     PathType(PathType),
1535     PtrType(PtrType),
1536     RefType(RefType),
1537     SliceType(SliceType),
1538     TupleType(TupleType),
1539 }
1540 
1541 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1542 pub enum Expr {
1543     ArrayExpr(ArrayExpr),
1544     AwaitExpr(AwaitExpr),
1545     BinExpr(BinExpr),
1546     BlockExpr(BlockExpr),
1547     BoxExpr(BoxExpr),
1548     BreakExpr(BreakExpr),
1549     CallExpr(CallExpr),
1550     CastExpr(CastExpr),
1551     ClosureExpr(ClosureExpr),
1552     ContinueExpr(ContinueExpr),
1553     FieldExpr(FieldExpr),
1554     ForExpr(ForExpr),
1555     IfExpr(IfExpr),
1556     IndexExpr(IndexExpr),
1557     Literal(Literal),
1558     LoopExpr(LoopExpr),
1559     MacroExpr(MacroExpr),
1560     MatchExpr(MatchExpr),
1561     MethodCallExpr(MethodCallExpr),
1562     ParenExpr(ParenExpr),
1563     PathExpr(PathExpr),
1564     PrefixExpr(PrefixExpr),
1565     RangeExpr(RangeExpr),
1566     RecordExpr(RecordExpr),
1567     RefExpr(RefExpr),
1568     ReturnExpr(ReturnExpr),
1569     TryExpr(TryExpr),
1570     TupleExpr(TupleExpr),
1571     WhileExpr(WhileExpr),
1572     YieldExpr(YieldExpr),
1573     YeetExpr(YeetExpr),
1574     LetExpr(LetExpr),
1575     UnderscoreExpr(UnderscoreExpr),
1576 }
1577 
1578 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1579 pub enum Item {
1580     Const(Const),
1581     Enum(Enum),
1582     ExternBlock(ExternBlock),
1583     ExternCrate(ExternCrate),
1584     Fn(Fn),
1585     Impl(Impl),
1586     MacroCall(MacroCall),
1587     MacroRules(MacroRules),
1588     MacroDef(MacroDef),
1589     Module(Module),
1590     Static(Static),
1591     Struct(Struct),
1592     Trait(Trait),
1593     TraitAlias(TraitAlias),
1594     TypeAlias(TypeAlias),
1595     Union(Union),
1596     Use(Use),
1597 }
1598 impl ast::HasAttrs for Item {}
1599 impl ast::HasDocComments for Item {}
1600 
1601 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1602 pub enum Stmt {
1603     ExprStmt(ExprStmt),
1604     Item(Item),
1605     LetStmt(LetStmt),
1606 }
1607 
1608 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1609 pub enum Pat {
1610     IdentPat(IdentPat),
1611     BoxPat(BoxPat),
1612     RestPat(RestPat),
1613     LiteralPat(LiteralPat),
1614     MacroPat(MacroPat),
1615     OrPat(OrPat),
1616     ParenPat(ParenPat),
1617     PathPat(PathPat),
1618     WildcardPat(WildcardPat),
1619     RangePat(RangePat),
1620     RecordPat(RecordPat),
1621     RefPat(RefPat),
1622     SlicePat(SlicePat),
1623     TuplePat(TuplePat),
1624     TupleStructPat(TupleStructPat),
1625     ConstBlockPat(ConstBlockPat),
1626 }
1627 
1628 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1629 pub enum FieldList {
1630     RecordFieldList(RecordFieldList),
1631     TupleFieldList(TupleFieldList),
1632 }
1633 
1634 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1635 pub enum Adt {
1636     Enum(Enum),
1637     Struct(Struct),
1638     Union(Union),
1639 }
1640 impl ast::HasAttrs for Adt {}
1641 impl ast::HasDocComments for Adt {}
1642 impl ast::HasGenericParams for Adt {}
1643 impl ast::HasName for Adt {}
1644 impl ast::HasVisibility for Adt {}
1645 
1646 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1647 pub enum AssocItem {
1648     Const(Const),
1649     Fn(Fn),
1650     MacroCall(MacroCall),
1651     TypeAlias(TypeAlias),
1652 }
1653 impl ast::HasAttrs for AssocItem {}
1654 impl ast::HasDocComments for AssocItem {}
1655 
1656 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1657 pub enum ExternItem {
1658     Fn(Fn),
1659     MacroCall(MacroCall),
1660     Static(Static),
1661     TypeAlias(TypeAlias),
1662 }
1663 impl ast::HasAttrs for ExternItem {}
1664 impl ast::HasDocComments for ExternItem {}
1665 
1666 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1667 pub enum GenericParam {
1668     ConstParam(ConstParam),
1669     LifetimeParam(LifetimeParam),
1670     TypeParam(TypeParam),
1671 }
1672 impl ast::HasAttrs for GenericParam {}
1673 
1674 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1675 pub struct AnyHasArgList {
1676     pub(crate) syntax: SyntaxNode,
1677 }
1678 impl ast::HasArgList for AnyHasArgList {}
1679 
1680 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1681 pub struct AnyHasAttrs {
1682     pub(crate) syntax: SyntaxNode,
1683 }
1684 impl ast::HasAttrs for AnyHasAttrs {}
1685 
1686 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1687 pub struct AnyHasDocComments {
1688     pub(crate) syntax: SyntaxNode,
1689 }
1690 impl ast::HasDocComments for AnyHasDocComments {}
1691 
1692 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1693 pub struct AnyHasGenericParams {
1694     pub(crate) syntax: SyntaxNode,
1695 }
1696 impl ast::HasGenericParams for AnyHasGenericParams {}
1697 
1698 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1699 pub struct AnyHasLoopBody {
1700     pub(crate) syntax: SyntaxNode,
1701 }
1702 impl ast::HasLoopBody for AnyHasLoopBody {}
1703 
1704 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1705 pub struct AnyHasModuleItem {
1706     pub(crate) syntax: SyntaxNode,
1707 }
1708 impl ast::HasModuleItem for AnyHasModuleItem {}
1709 
1710 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1711 pub struct AnyHasName {
1712     pub(crate) syntax: SyntaxNode,
1713 }
1714 impl ast::HasName for AnyHasName {}
1715 
1716 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1717 pub struct AnyHasTypeBounds {
1718     pub(crate) syntax: SyntaxNode,
1719 }
1720 impl ast::HasTypeBounds for AnyHasTypeBounds {}
1721 
1722 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1723 pub struct AnyHasVisibility {
1724     pub(crate) syntax: SyntaxNode,
1725 }
1726 impl ast::HasVisibility for AnyHasVisibility {}
1727 impl AstNode for Name {
can_cast(kind: SyntaxKind) -> bool1728     fn can_cast(kind: SyntaxKind) -> bool { kind == NAME }
cast(syntax: SyntaxNode) -> Option<Self>1729     fn cast(syntax: SyntaxNode) -> Option<Self> {
1730         if Self::can_cast(syntax.kind()) {
1731             Some(Self { syntax })
1732         } else {
1733             None
1734         }
1735     }
syntax(&self) -> &SyntaxNode1736     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1737 }
1738 impl AstNode for NameRef {
can_cast(kind: SyntaxKind) -> bool1739     fn can_cast(kind: SyntaxKind) -> bool { kind == NAME_REF }
cast(syntax: SyntaxNode) -> Option<Self>1740     fn cast(syntax: SyntaxNode) -> Option<Self> {
1741         if Self::can_cast(syntax.kind()) {
1742             Some(Self { syntax })
1743         } else {
1744             None
1745         }
1746     }
syntax(&self) -> &SyntaxNode1747     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1748 }
1749 impl AstNode for Lifetime {
can_cast(kind: SyntaxKind) -> bool1750     fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME }
cast(syntax: SyntaxNode) -> Option<Self>1751     fn cast(syntax: SyntaxNode) -> Option<Self> {
1752         if Self::can_cast(syntax.kind()) {
1753             Some(Self { syntax })
1754         } else {
1755             None
1756         }
1757     }
syntax(&self) -> &SyntaxNode1758     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1759 }
1760 impl AstNode for Path {
can_cast(kind: SyntaxKind) -> bool1761     fn can_cast(kind: SyntaxKind) -> bool { kind == PATH }
cast(syntax: SyntaxNode) -> Option<Self>1762     fn cast(syntax: SyntaxNode) -> Option<Self> {
1763         if Self::can_cast(syntax.kind()) {
1764             Some(Self { syntax })
1765         } else {
1766             None
1767         }
1768     }
syntax(&self) -> &SyntaxNode1769     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1770 }
1771 impl AstNode for PathSegment {
can_cast(kind: SyntaxKind) -> bool1772     fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_SEGMENT }
cast(syntax: SyntaxNode) -> Option<Self>1773     fn cast(syntax: SyntaxNode) -> Option<Self> {
1774         if Self::can_cast(syntax.kind()) {
1775             Some(Self { syntax })
1776         } else {
1777             None
1778         }
1779     }
syntax(&self) -> &SyntaxNode1780     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1781 }
1782 impl AstNode for GenericArgList {
can_cast(kind: SyntaxKind) -> bool1783     fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_ARG_LIST }
cast(syntax: SyntaxNode) -> Option<Self>1784     fn cast(syntax: SyntaxNode) -> Option<Self> {
1785         if Self::can_cast(syntax.kind()) {
1786             Some(Self { syntax })
1787         } else {
1788             None
1789         }
1790     }
syntax(&self) -> &SyntaxNode1791     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1792 }
1793 impl AstNode for ParamList {
can_cast(kind: SyntaxKind) -> bool1794     fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM_LIST }
cast(syntax: SyntaxNode) -> Option<Self>1795     fn cast(syntax: SyntaxNode) -> Option<Self> {
1796         if Self::can_cast(syntax.kind()) {
1797             Some(Self { syntax })
1798         } else {
1799             None
1800         }
1801     }
syntax(&self) -> &SyntaxNode1802     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1803 }
1804 impl AstNode for RetType {
can_cast(kind: SyntaxKind) -> bool1805     fn can_cast(kind: SyntaxKind) -> bool { kind == RET_TYPE }
cast(syntax: SyntaxNode) -> Option<Self>1806     fn cast(syntax: SyntaxNode) -> Option<Self> {
1807         if Self::can_cast(syntax.kind()) {
1808             Some(Self { syntax })
1809         } else {
1810             None
1811         }
1812     }
syntax(&self) -> &SyntaxNode1813     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1814 }
1815 impl AstNode for PathType {
can_cast(kind: SyntaxKind) -> bool1816     fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_TYPE }
cast(syntax: SyntaxNode) -> Option<Self>1817     fn cast(syntax: SyntaxNode) -> Option<Self> {
1818         if Self::can_cast(syntax.kind()) {
1819             Some(Self { syntax })
1820         } else {
1821             None
1822         }
1823     }
syntax(&self) -> &SyntaxNode1824     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1825 }
1826 impl AstNode for TypeArg {
can_cast(kind: SyntaxKind) -> bool1827     fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ARG }
cast(syntax: SyntaxNode) -> Option<Self>1828     fn cast(syntax: SyntaxNode) -> Option<Self> {
1829         if Self::can_cast(syntax.kind()) {
1830             Some(Self { syntax })
1831         } else {
1832             None
1833         }
1834     }
syntax(&self) -> &SyntaxNode1835     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1836 }
1837 impl AstNode for AssocTypeArg {
can_cast(kind: SyntaxKind) -> bool1838     fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_TYPE_ARG }
cast(syntax: SyntaxNode) -> Option<Self>1839     fn cast(syntax: SyntaxNode) -> Option<Self> {
1840         if Self::can_cast(syntax.kind()) {
1841             Some(Self { syntax })
1842         } else {
1843             None
1844         }
1845     }
syntax(&self) -> &SyntaxNode1846     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1847 }
1848 impl AstNode for LifetimeArg {
can_cast(kind: SyntaxKind) -> bool1849     fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_ARG }
cast(syntax: SyntaxNode) -> Option<Self>1850     fn cast(syntax: SyntaxNode) -> Option<Self> {
1851         if Self::can_cast(syntax.kind()) {
1852             Some(Self { syntax })
1853         } else {
1854             None
1855         }
1856     }
syntax(&self) -> &SyntaxNode1857     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1858 }
1859 impl AstNode for ConstArg {
can_cast(kind: SyntaxKind) -> bool1860     fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_ARG }
cast(syntax: SyntaxNode) -> Option<Self>1861     fn cast(syntax: SyntaxNode) -> Option<Self> {
1862         if Self::can_cast(syntax.kind()) {
1863             Some(Self { syntax })
1864         } else {
1865             None
1866         }
1867     }
syntax(&self) -> &SyntaxNode1868     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1869 }
1870 impl AstNode for TypeBoundList {
can_cast(kind: SyntaxKind) -> bool1871     fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND_LIST }
cast(syntax: SyntaxNode) -> Option<Self>1872     fn cast(syntax: SyntaxNode) -> Option<Self> {
1873         if Self::can_cast(syntax.kind()) {
1874             Some(Self { syntax })
1875         } else {
1876             None
1877         }
1878     }
syntax(&self) -> &SyntaxNode1879     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1880 }
1881 impl AstNode for MacroCall {
can_cast(kind: SyntaxKind) -> bool1882     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_CALL }
cast(syntax: SyntaxNode) -> Option<Self>1883     fn cast(syntax: SyntaxNode) -> Option<Self> {
1884         if Self::can_cast(syntax.kind()) {
1885             Some(Self { syntax })
1886         } else {
1887             None
1888         }
1889     }
syntax(&self) -> &SyntaxNode1890     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1891 }
1892 impl AstNode for Attr {
can_cast(kind: SyntaxKind) -> bool1893     fn can_cast(kind: SyntaxKind) -> bool { kind == ATTR }
cast(syntax: SyntaxNode) -> Option<Self>1894     fn cast(syntax: SyntaxNode) -> Option<Self> {
1895         if Self::can_cast(syntax.kind()) {
1896             Some(Self { syntax })
1897         } else {
1898             None
1899         }
1900     }
syntax(&self) -> &SyntaxNode1901     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1902 }
1903 impl AstNode for TokenTree {
can_cast(kind: SyntaxKind) -> bool1904     fn can_cast(kind: SyntaxKind) -> bool { kind == TOKEN_TREE }
cast(syntax: SyntaxNode) -> Option<Self>1905     fn cast(syntax: SyntaxNode) -> Option<Self> {
1906         if Self::can_cast(syntax.kind()) {
1907             Some(Self { syntax })
1908         } else {
1909             None
1910         }
1911     }
syntax(&self) -> &SyntaxNode1912     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1913 }
1914 impl AstNode for MacroItems {
can_cast(kind: SyntaxKind) -> bool1915     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_ITEMS }
cast(syntax: SyntaxNode) -> Option<Self>1916     fn cast(syntax: SyntaxNode) -> Option<Self> {
1917         if Self::can_cast(syntax.kind()) {
1918             Some(Self { syntax })
1919         } else {
1920             None
1921         }
1922     }
syntax(&self) -> &SyntaxNode1923     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1924 }
1925 impl AstNode for MacroStmts {
can_cast(kind: SyntaxKind) -> bool1926     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_STMTS }
cast(syntax: SyntaxNode) -> Option<Self>1927     fn cast(syntax: SyntaxNode) -> Option<Self> {
1928         if Self::can_cast(syntax.kind()) {
1929             Some(Self { syntax })
1930         } else {
1931             None
1932         }
1933     }
syntax(&self) -> &SyntaxNode1934     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1935 }
1936 impl AstNode for SourceFile {
can_cast(kind: SyntaxKind) -> bool1937     fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE }
cast(syntax: SyntaxNode) -> Option<Self>1938     fn cast(syntax: SyntaxNode) -> Option<Self> {
1939         if Self::can_cast(syntax.kind()) {
1940             Some(Self { syntax })
1941         } else {
1942             None
1943         }
1944     }
syntax(&self) -> &SyntaxNode1945     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1946 }
1947 impl AstNode for Const {
can_cast(kind: SyntaxKind) -> bool1948     fn can_cast(kind: SyntaxKind) -> bool { kind == CONST }
cast(syntax: SyntaxNode) -> Option<Self>1949     fn cast(syntax: SyntaxNode) -> Option<Self> {
1950         if Self::can_cast(syntax.kind()) {
1951             Some(Self { syntax })
1952         } else {
1953             None
1954         }
1955     }
syntax(&self) -> &SyntaxNode1956     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1957 }
1958 impl AstNode for Enum {
can_cast(kind: SyntaxKind) -> bool1959     fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM }
cast(syntax: SyntaxNode) -> Option<Self>1960     fn cast(syntax: SyntaxNode) -> Option<Self> {
1961         if Self::can_cast(syntax.kind()) {
1962             Some(Self { syntax })
1963         } else {
1964             None
1965         }
1966     }
syntax(&self) -> &SyntaxNode1967     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1968 }
1969 impl AstNode for ExternBlock {
can_cast(kind: SyntaxKind) -> bool1970     fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_BLOCK }
cast(syntax: SyntaxNode) -> Option<Self>1971     fn cast(syntax: SyntaxNode) -> Option<Self> {
1972         if Self::can_cast(syntax.kind()) {
1973             Some(Self { syntax })
1974         } else {
1975             None
1976         }
1977     }
syntax(&self) -> &SyntaxNode1978     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1979 }
1980 impl AstNode for ExternCrate {
can_cast(kind: SyntaxKind) -> bool1981     fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_CRATE }
cast(syntax: SyntaxNode) -> Option<Self>1982     fn cast(syntax: SyntaxNode) -> Option<Self> {
1983         if Self::can_cast(syntax.kind()) {
1984             Some(Self { syntax })
1985         } else {
1986             None
1987         }
1988     }
syntax(&self) -> &SyntaxNode1989     fn syntax(&self) -> &SyntaxNode { &self.syntax }
1990 }
1991 impl AstNode for Fn {
can_cast(kind: SyntaxKind) -> bool1992     fn can_cast(kind: SyntaxKind) -> bool { kind == FN }
cast(syntax: SyntaxNode) -> Option<Self>1993     fn cast(syntax: SyntaxNode) -> Option<Self> {
1994         if Self::can_cast(syntax.kind()) {
1995             Some(Self { syntax })
1996         } else {
1997             None
1998         }
1999     }
syntax(&self) -> &SyntaxNode2000     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2001 }
2002 impl AstNode for Impl {
can_cast(kind: SyntaxKind) -> bool2003     fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL }
cast(syntax: SyntaxNode) -> Option<Self>2004     fn cast(syntax: SyntaxNode) -> Option<Self> {
2005         if Self::can_cast(syntax.kind()) {
2006             Some(Self { syntax })
2007         } else {
2008             None
2009         }
2010     }
syntax(&self) -> &SyntaxNode2011     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2012 }
2013 impl AstNode for MacroRules {
can_cast(kind: SyntaxKind) -> bool2014     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_RULES }
cast(syntax: SyntaxNode) -> Option<Self>2015     fn cast(syntax: SyntaxNode) -> Option<Self> {
2016         if Self::can_cast(syntax.kind()) {
2017             Some(Self { syntax })
2018         } else {
2019             None
2020         }
2021     }
syntax(&self) -> &SyntaxNode2022     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2023 }
2024 impl AstNode for MacroDef {
can_cast(kind: SyntaxKind) -> bool2025     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_DEF }
cast(syntax: SyntaxNode) -> Option<Self>2026     fn cast(syntax: SyntaxNode) -> Option<Self> {
2027         if Self::can_cast(syntax.kind()) {
2028             Some(Self { syntax })
2029         } else {
2030             None
2031         }
2032     }
syntax(&self) -> &SyntaxNode2033     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2034 }
2035 impl AstNode for Module {
can_cast(kind: SyntaxKind) -> bool2036     fn can_cast(kind: SyntaxKind) -> bool { kind == MODULE }
cast(syntax: SyntaxNode) -> Option<Self>2037     fn cast(syntax: SyntaxNode) -> Option<Self> {
2038         if Self::can_cast(syntax.kind()) {
2039             Some(Self { syntax })
2040         } else {
2041             None
2042         }
2043     }
syntax(&self) -> &SyntaxNode2044     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2045 }
2046 impl AstNode for Static {
can_cast(kind: SyntaxKind) -> bool2047     fn can_cast(kind: SyntaxKind) -> bool { kind == STATIC }
cast(syntax: SyntaxNode) -> Option<Self>2048     fn cast(syntax: SyntaxNode) -> Option<Self> {
2049         if Self::can_cast(syntax.kind()) {
2050             Some(Self { syntax })
2051         } else {
2052             None
2053         }
2054     }
syntax(&self) -> &SyntaxNode2055     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2056 }
2057 impl AstNode for Struct {
can_cast(kind: SyntaxKind) -> bool2058     fn can_cast(kind: SyntaxKind) -> bool { kind == STRUCT }
cast(syntax: SyntaxNode) -> Option<Self>2059     fn cast(syntax: SyntaxNode) -> Option<Self> {
2060         if Self::can_cast(syntax.kind()) {
2061             Some(Self { syntax })
2062         } else {
2063             None
2064         }
2065     }
syntax(&self) -> &SyntaxNode2066     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2067 }
2068 impl AstNode for Trait {
can_cast(kind: SyntaxKind) -> bool2069     fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT }
cast(syntax: SyntaxNode) -> Option<Self>2070     fn cast(syntax: SyntaxNode) -> Option<Self> {
2071         if Self::can_cast(syntax.kind()) {
2072             Some(Self { syntax })
2073         } else {
2074             None
2075         }
2076     }
syntax(&self) -> &SyntaxNode2077     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2078 }
2079 impl AstNode for TraitAlias {
can_cast(kind: SyntaxKind) -> bool2080     fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT_ALIAS }
cast(syntax: SyntaxNode) -> Option<Self>2081     fn cast(syntax: SyntaxNode) -> Option<Self> {
2082         if Self::can_cast(syntax.kind()) {
2083             Some(Self { syntax })
2084         } else {
2085             None
2086         }
2087     }
syntax(&self) -> &SyntaxNode2088     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2089 }
2090 impl AstNode for TypeAlias {
can_cast(kind: SyntaxKind) -> bool2091     fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ALIAS }
cast(syntax: SyntaxNode) -> Option<Self>2092     fn cast(syntax: SyntaxNode) -> Option<Self> {
2093         if Self::can_cast(syntax.kind()) {
2094             Some(Self { syntax })
2095         } else {
2096             None
2097         }
2098     }
syntax(&self) -> &SyntaxNode2099     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2100 }
2101 impl AstNode for Union {
can_cast(kind: SyntaxKind) -> bool2102     fn can_cast(kind: SyntaxKind) -> bool { kind == UNION }
cast(syntax: SyntaxNode) -> Option<Self>2103     fn cast(syntax: SyntaxNode) -> Option<Self> {
2104         if Self::can_cast(syntax.kind()) {
2105             Some(Self { syntax })
2106         } else {
2107             None
2108         }
2109     }
syntax(&self) -> &SyntaxNode2110     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2111 }
2112 impl AstNode for Use {
can_cast(kind: SyntaxKind) -> bool2113     fn can_cast(kind: SyntaxKind) -> bool { kind == USE }
cast(syntax: SyntaxNode) -> Option<Self>2114     fn cast(syntax: SyntaxNode) -> Option<Self> {
2115         if Self::can_cast(syntax.kind()) {
2116             Some(Self { syntax })
2117         } else {
2118             None
2119         }
2120     }
syntax(&self) -> &SyntaxNode2121     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2122 }
2123 impl AstNode for Visibility {
can_cast(kind: SyntaxKind) -> bool2124     fn can_cast(kind: SyntaxKind) -> bool { kind == VISIBILITY }
cast(syntax: SyntaxNode) -> Option<Self>2125     fn cast(syntax: SyntaxNode) -> Option<Self> {
2126         if Self::can_cast(syntax.kind()) {
2127             Some(Self { syntax })
2128         } else {
2129             None
2130         }
2131     }
syntax(&self) -> &SyntaxNode2132     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2133 }
2134 impl AstNode for ItemList {
can_cast(kind: SyntaxKind) -> bool2135     fn can_cast(kind: SyntaxKind) -> bool { kind == ITEM_LIST }
cast(syntax: SyntaxNode) -> Option<Self>2136     fn cast(syntax: SyntaxNode) -> Option<Self> {
2137         if Self::can_cast(syntax.kind()) {
2138             Some(Self { syntax })
2139         } else {
2140             None
2141         }
2142     }
syntax(&self) -> &SyntaxNode2143     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2144 }
2145 impl AstNode for Rename {
can_cast(kind: SyntaxKind) -> bool2146     fn can_cast(kind: SyntaxKind) -> bool { kind == RENAME }
cast(syntax: SyntaxNode) -> Option<Self>2147     fn cast(syntax: SyntaxNode) -> Option<Self> {
2148         if Self::can_cast(syntax.kind()) {
2149             Some(Self { syntax })
2150         } else {
2151             None
2152         }
2153     }
syntax(&self) -> &SyntaxNode2154     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2155 }
2156 impl AstNode for UseTree {
can_cast(kind: SyntaxKind) -> bool2157     fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE }
cast(syntax: SyntaxNode) -> Option<Self>2158     fn cast(syntax: SyntaxNode) -> Option<Self> {
2159         if Self::can_cast(syntax.kind()) {
2160             Some(Self { syntax })
2161         } else {
2162             None
2163         }
2164     }
syntax(&self) -> &SyntaxNode2165     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2166 }
2167 impl AstNode for UseTreeList {
can_cast(kind: SyntaxKind) -> bool2168     fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE_LIST }
cast(syntax: SyntaxNode) -> Option<Self>2169     fn cast(syntax: SyntaxNode) -> Option<Self> {
2170         if Self::can_cast(syntax.kind()) {
2171             Some(Self { syntax })
2172         } else {
2173             None
2174         }
2175     }
syntax(&self) -> &SyntaxNode2176     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2177 }
2178 impl AstNode for Abi {
can_cast(kind: SyntaxKind) -> bool2179     fn can_cast(kind: SyntaxKind) -> bool { kind == ABI }
cast(syntax: SyntaxNode) -> Option<Self>2180     fn cast(syntax: SyntaxNode) -> Option<Self> {
2181         if Self::can_cast(syntax.kind()) {
2182             Some(Self { syntax })
2183         } else {
2184             None
2185         }
2186     }
syntax(&self) -> &SyntaxNode2187     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2188 }
2189 impl AstNode for GenericParamList {
can_cast(kind: SyntaxKind) -> bool2190     fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_PARAM_LIST }
cast(syntax: SyntaxNode) -> Option<Self>2191     fn cast(syntax: SyntaxNode) -> Option<Self> {
2192         if Self::can_cast(syntax.kind()) {
2193             Some(Self { syntax })
2194         } else {
2195             None
2196         }
2197     }
syntax(&self) -> &SyntaxNode2198     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2199 }
2200 impl AstNode for WhereClause {
can_cast(kind: SyntaxKind) -> bool2201     fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_CLAUSE }
cast(syntax: SyntaxNode) -> Option<Self>2202     fn cast(syntax: SyntaxNode) -> Option<Self> {
2203         if Self::can_cast(syntax.kind()) {
2204             Some(Self { syntax })
2205         } else {
2206             None
2207         }
2208     }
syntax(&self) -> &SyntaxNode2209     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2210 }
2211 impl AstNode for BlockExpr {
can_cast(kind: SyntaxKind) -> bool2212     fn can_cast(kind: SyntaxKind) -> bool { kind == BLOCK_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2213     fn cast(syntax: SyntaxNode) -> Option<Self> {
2214         if Self::can_cast(syntax.kind()) {
2215             Some(Self { syntax })
2216         } else {
2217             None
2218         }
2219     }
syntax(&self) -> &SyntaxNode2220     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2221 }
2222 impl AstNode for SelfParam {
can_cast(kind: SyntaxKind) -> bool2223     fn can_cast(kind: SyntaxKind) -> bool { kind == SELF_PARAM }
cast(syntax: SyntaxNode) -> Option<Self>2224     fn cast(syntax: SyntaxNode) -> Option<Self> {
2225         if Self::can_cast(syntax.kind()) {
2226             Some(Self { syntax })
2227         } else {
2228             None
2229         }
2230     }
syntax(&self) -> &SyntaxNode2231     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2232 }
2233 impl AstNode for Param {
can_cast(kind: SyntaxKind) -> bool2234     fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM }
cast(syntax: SyntaxNode) -> Option<Self>2235     fn cast(syntax: SyntaxNode) -> Option<Self> {
2236         if Self::can_cast(syntax.kind()) {
2237             Some(Self { syntax })
2238         } else {
2239             None
2240         }
2241     }
syntax(&self) -> &SyntaxNode2242     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2243 }
2244 impl AstNode for RecordFieldList {
can_cast(kind: SyntaxKind) -> bool2245     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_LIST }
cast(syntax: SyntaxNode) -> Option<Self>2246     fn cast(syntax: SyntaxNode) -> Option<Self> {
2247         if Self::can_cast(syntax.kind()) {
2248             Some(Self { syntax })
2249         } else {
2250             None
2251         }
2252     }
syntax(&self) -> &SyntaxNode2253     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2254 }
2255 impl AstNode for TupleFieldList {
can_cast(kind: SyntaxKind) -> bool2256     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD_LIST }
cast(syntax: SyntaxNode) -> Option<Self>2257     fn cast(syntax: SyntaxNode) -> Option<Self> {
2258         if Self::can_cast(syntax.kind()) {
2259             Some(Self { syntax })
2260         } else {
2261             None
2262         }
2263     }
syntax(&self) -> &SyntaxNode2264     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2265 }
2266 impl AstNode for RecordField {
can_cast(kind: SyntaxKind) -> bool2267     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD }
cast(syntax: SyntaxNode) -> Option<Self>2268     fn cast(syntax: SyntaxNode) -> Option<Self> {
2269         if Self::can_cast(syntax.kind()) {
2270             Some(Self { syntax })
2271         } else {
2272             None
2273         }
2274     }
syntax(&self) -> &SyntaxNode2275     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2276 }
2277 impl AstNode for TupleField {
can_cast(kind: SyntaxKind) -> bool2278     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD }
cast(syntax: SyntaxNode) -> Option<Self>2279     fn cast(syntax: SyntaxNode) -> Option<Self> {
2280         if Self::can_cast(syntax.kind()) {
2281             Some(Self { syntax })
2282         } else {
2283             None
2284         }
2285     }
syntax(&self) -> &SyntaxNode2286     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2287 }
2288 impl AstNode for VariantList {
can_cast(kind: SyntaxKind) -> bool2289     fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT_LIST }
cast(syntax: SyntaxNode) -> Option<Self>2290     fn cast(syntax: SyntaxNode) -> Option<Self> {
2291         if Self::can_cast(syntax.kind()) {
2292             Some(Self { syntax })
2293         } else {
2294             None
2295         }
2296     }
syntax(&self) -> &SyntaxNode2297     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2298 }
2299 impl AstNode for Variant {
can_cast(kind: SyntaxKind) -> bool2300     fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT }
cast(syntax: SyntaxNode) -> Option<Self>2301     fn cast(syntax: SyntaxNode) -> Option<Self> {
2302         if Self::can_cast(syntax.kind()) {
2303             Some(Self { syntax })
2304         } else {
2305             None
2306         }
2307     }
syntax(&self) -> &SyntaxNode2308     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2309 }
2310 impl AstNode for AssocItemList {
can_cast(kind: SyntaxKind) -> bool2311     fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_ITEM_LIST }
cast(syntax: SyntaxNode) -> Option<Self>2312     fn cast(syntax: SyntaxNode) -> Option<Self> {
2313         if Self::can_cast(syntax.kind()) {
2314             Some(Self { syntax })
2315         } else {
2316             None
2317         }
2318     }
syntax(&self) -> &SyntaxNode2319     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2320 }
2321 impl AstNode for ExternItemList {
can_cast(kind: SyntaxKind) -> bool2322     fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_ITEM_LIST }
cast(syntax: SyntaxNode) -> Option<Self>2323     fn cast(syntax: SyntaxNode) -> Option<Self> {
2324         if Self::can_cast(syntax.kind()) {
2325             Some(Self { syntax })
2326         } else {
2327             None
2328         }
2329     }
syntax(&self) -> &SyntaxNode2330     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2331 }
2332 impl AstNode for ConstParam {
can_cast(kind: SyntaxKind) -> bool2333     fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_PARAM }
cast(syntax: SyntaxNode) -> Option<Self>2334     fn cast(syntax: SyntaxNode) -> Option<Self> {
2335         if Self::can_cast(syntax.kind()) {
2336             Some(Self { syntax })
2337         } else {
2338             None
2339         }
2340     }
syntax(&self) -> &SyntaxNode2341     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2342 }
2343 impl AstNode for LifetimeParam {
can_cast(kind: SyntaxKind) -> bool2344     fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_PARAM }
cast(syntax: SyntaxNode) -> Option<Self>2345     fn cast(syntax: SyntaxNode) -> Option<Self> {
2346         if Self::can_cast(syntax.kind()) {
2347             Some(Self { syntax })
2348         } else {
2349             None
2350         }
2351     }
syntax(&self) -> &SyntaxNode2352     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2353 }
2354 impl AstNode for TypeParam {
can_cast(kind: SyntaxKind) -> bool2355     fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_PARAM }
cast(syntax: SyntaxNode) -> Option<Self>2356     fn cast(syntax: SyntaxNode) -> Option<Self> {
2357         if Self::can_cast(syntax.kind()) {
2358             Some(Self { syntax })
2359         } else {
2360             None
2361         }
2362     }
syntax(&self) -> &SyntaxNode2363     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2364 }
2365 impl AstNode for WherePred {
can_cast(kind: SyntaxKind) -> bool2366     fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_PRED }
cast(syntax: SyntaxNode) -> Option<Self>2367     fn cast(syntax: SyntaxNode) -> Option<Self> {
2368         if Self::can_cast(syntax.kind()) {
2369             Some(Self { syntax })
2370         } else {
2371             None
2372         }
2373     }
syntax(&self) -> &SyntaxNode2374     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2375 }
2376 impl AstNode for Meta {
can_cast(kind: SyntaxKind) -> bool2377     fn can_cast(kind: SyntaxKind) -> bool { kind == META }
cast(syntax: SyntaxNode) -> Option<Self>2378     fn cast(syntax: SyntaxNode) -> Option<Self> {
2379         if Self::can_cast(syntax.kind()) {
2380             Some(Self { syntax })
2381         } else {
2382             None
2383         }
2384     }
syntax(&self) -> &SyntaxNode2385     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2386 }
2387 impl AstNode for ExprStmt {
can_cast(kind: SyntaxKind) -> bool2388     fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_STMT }
cast(syntax: SyntaxNode) -> Option<Self>2389     fn cast(syntax: SyntaxNode) -> Option<Self> {
2390         if Self::can_cast(syntax.kind()) {
2391             Some(Self { syntax })
2392         } else {
2393             None
2394         }
2395     }
syntax(&self) -> &SyntaxNode2396     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2397 }
2398 impl AstNode for LetStmt {
can_cast(kind: SyntaxKind) -> bool2399     fn can_cast(kind: SyntaxKind) -> bool { kind == LET_STMT }
cast(syntax: SyntaxNode) -> Option<Self>2400     fn cast(syntax: SyntaxNode) -> Option<Self> {
2401         if Self::can_cast(syntax.kind()) {
2402             Some(Self { syntax })
2403         } else {
2404             None
2405         }
2406     }
syntax(&self) -> &SyntaxNode2407     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2408 }
2409 impl AstNode for LetElse {
can_cast(kind: SyntaxKind) -> bool2410     fn can_cast(kind: SyntaxKind) -> bool { kind == LET_ELSE }
cast(syntax: SyntaxNode) -> Option<Self>2411     fn cast(syntax: SyntaxNode) -> Option<Self> {
2412         if Self::can_cast(syntax.kind()) {
2413             Some(Self { syntax })
2414         } else {
2415             None
2416         }
2417     }
syntax(&self) -> &SyntaxNode2418     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2419 }
2420 impl AstNode for ArrayExpr {
can_cast(kind: SyntaxKind) -> bool2421     fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2422     fn cast(syntax: SyntaxNode) -> Option<Self> {
2423         if Self::can_cast(syntax.kind()) {
2424             Some(Self { syntax })
2425         } else {
2426             None
2427         }
2428     }
syntax(&self) -> &SyntaxNode2429     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2430 }
2431 impl AstNode for AwaitExpr {
can_cast(kind: SyntaxKind) -> bool2432     fn can_cast(kind: SyntaxKind) -> bool { kind == AWAIT_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2433     fn cast(syntax: SyntaxNode) -> Option<Self> {
2434         if Self::can_cast(syntax.kind()) {
2435             Some(Self { syntax })
2436         } else {
2437             None
2438         }
2439     }
syntax(&self) -> &SyntaxNode2440     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2441 }
2442 impl AstNode for BinExpr {
can_cast(kind: SyntaxKind) -> bool2443     fn can_cast(kind: SyntaxKind) -> bool { kind == BIN_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2444     fn cast(syntax: SyntaxNode) -> Option<Self> {
2445         if Self::can_cast(syntax.kind()) {
2446             Some(Self { syntax })
2447         } else {
2448             None
2449         }
2450     }
syntax(&self) -> &SyntaxNode2451     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2452 }
2453 impl AstNode for BoxExpr {
can_cast(kind: SyntaxKind) -> bool2454     fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2455     fn cast(syntax: SyntaxNode) -> Option<Self> {
2456         if Self::can_cast(syntax.kind()) {
2457             Some(Self { syntax })
2458         } else {
2459             None
2460         }
2461     }
syntax(&self) -> &SyntaxNode2462     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2463 }
2464 impl AstNode for BreakExpr {
can_cast(kind: SyntaxKind) -> bool2465     fn can_cast(kind: SyntaxKind) -> bool { kind == BREAK_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2466     fn cast(syntax: SyntaxNode) -> Option<Self> {
2467         if Self::can_cast(syntax.kind()) {
2468             Some(Self { syntax })
2469         } else {
2470             None
2471         }
2472     }
syntax(&self) -> &SyntaxNode2473     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2474 }
2475 impl AstNode for CallExpr {
can_cast(kind: SyntaxKind) -> bool2476     fn can_cast(kind: SyntaxKind) -> bool { kind == CALL_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2477     fn cast(syntax: SyntaxNode) -> Option<Self> {
2478         if Self::can_cast(syntax.kind()) {
2479             Some(Self { syntax })
2480         } else {
2481             None
2482         }
2483     }
syntax(&self) -> &SyntaxNode2484     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2485 }
2486 impl AstNode for CastExpr {
can_cast(kind: SyntaxKind) -> bool2487     fn can_cast(kind: SyntaxKind) -> bool { kind == CAST_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2488     fn cast(syntax: SyntaxNode) -> Option<Self> {
2489         if Self::can_cast(syntax.kind()) {
2490             Some(Self { syntax })
2491         } else {
2492             None
2493         }
2494     }
syntax(&self) -> &SyntaxNode2495     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2496 }
2497 impl AstNode for ClosureExpr {
can_cast(kind: SyntaxKind) -> bool2498     fn can_cast(kind: SyntaxKind) -> bool { kind == CLOSURE_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2499     fn cast(syntax: SyntaxNode) -> Option<Self> {
2500         if Self::can_cast(syntax.kind()) {
2501             Some(Self { syntax })
2502         } else {
2503             None
2504         }
2505     }
syntax(&self) -> &SyntaxNode2506     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2507 }
2508 impl AstNode for ContinueExpr {
can_cast(kind: SyntaxKind) -> bool2509     fn can_cast(kind: SyntaxKind) -> bool { kind == CONTINUE_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2510     fn cast(syntax: SyntaxNode) -> Option<Self> {
2511         if Self::can_cast(syntax.kind()) {
2512             Some(Self { syntax })
2513         } else {
2514             None
2515         }
2516     }
syntax(&self) -> &SyntaxNode2517     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2518 }
2519 impl AstNode for FieldExpr {
can_cast(kind: SyntaxKind) -> bool2520     fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2521     fn cast(syntax: SyntaxNode) -> Option<Self> {
2522         if Self::can_cast(syntax.kind()) {
2523             Some(Self { syntax })
2524         } else {
2525             None
2526         }
2527     }
syntax(&self) -> &SyntaxNode2528     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2529 }
2530 impl AstNode for ForExpr {
can_cast(kind: SyntaxKind) -> bool2531     fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2532     fn cast(syntax: SyntaxNode) -> Option<Self> {
2533         if Self::can_cast(syntax.kind()) {
2534             Some(Self { syntax })
2535         } else {
2536             None
2537         }
2538     }
syntax(&self) -> &SyntaxNode2539     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2540 }
2541 impl AstNode for IfExpr {
can_cast(kind: SyntaxKind) -> bool2542     fn can_cast(kind: SyntaxKind) -> bool { kind == IF_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2543     fn cast(syntax: SyntaxNode) -> Option<Self> {
2544         if Self::can_cast(syntax.kind()) {
2545             Some(Self { syntax })
2546         } else {
2547             None
2548         }
2549     }
syntax(&self) -> &SyntaxNode2550     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2551 }
2552 impl AstNode for IndexExpr {
can_cast(kind: SyntaxKind) -> bool2553     fn can_cast(kind: SyntaxKind) -> bool { kind == INDEX_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2554     fn cast(syntax: SyntaxNode) -> Option<Self> {
2555         if Self::can_cast(syntax.kind()) {
2556             Some(Self { syntax })
2557         } else {
2558             None
2559         }
2560     }
syntax(&self) -> &SyntaxNode2561     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2562 }
2563 impl AstNode for Literal {
can_cast(kind: SyntaxKind) -> bool2564     fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL }
cast(syntax: SyntaxNode) -> Option<Self>2565     fn cast(syntax: SyntaxNode) -> Option<Self> {
2566         if Self::can_cast(syntax.kind()) {
2567             Some(Self { syntax })
2568         } else {
2569             None
2570         }
2571     }
syntax(&self) -> &SyntaxNode2572     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2573 }
2574 impl AstNode for LoopExpr {
can_cast(kind: SyntaxKind) -> bool2575     fn can_cast(kind: SyntaxKind) -> bool { kind == LOOP_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2576     fn cast(syntax: SyntaxNode) -> Option<Self> {
2577         if Self::can_cast(syntax.kind()) {
2578             Some(Self { syntax })
2579         } else {
2580             None
2581         }
2582     }
syntax(&self) -> &SyntaxNode2583     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2584 }
2585 impl AstNode for MacroExpr {
can_cast(kind: SyntaxKind) -> bool2586     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2587     fn cast(syntax: SyntaxNode) -> Option<Self> {
2588         if Self::can_cast(syntax.kind()) {
2589             Some(Self { syntax })
2590         } else {
2591             None
2592         }
2593     }
syntax(&self) -> &SyntaxNode2594     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2595 }
2596 impl AstNode for MatchExpr {
can_cast(kind: SyntaxKind) -> bool2597     fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2598     fn cast(syntax: SyntaxNode) -> Option<Self> {
2599         if Self::can_cast(syntax.kind()) {
2600             Some(Self { syntax })
2601         } else {
2602             None
2603         }
2604     }
syntax(&self) -> &SyntaxNode2605     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2606 }
2607 impl AstNode for MethodCallExpr {
can_cast(kind: SyntaxKind) -> bool2608     fn can_cast(kind: SyntaxKind) -> bool { kind == METHOD_CALL_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2609     fn cast(syntax: SyntaxNode) -> Option<Self> {
2610         if Self::can_cast(syntax.kind()) {
2611             Some(Self { syntax })
2612         } else {
2613             None
2614         }
2615     }
syntax(&self) -> &SyntaxNode2616     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2617 }
2618 impl AstNode for ParenExpr {
can_cast(kind: SyntaxKind) -> bool2619     fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2620     fn cast(syntax: SyntaxNode) -> Option<Self> {
2621         if Self::can_cast(syntax.kind()) {
2622             Some(Self { syntax })
2623         } else {
2624             None
2625         }
2626     }
syntax(&self) -> &SyntaxNode2627     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2628 }
2629 impl AstNode for PathExpr {
can_cast(kind: SyntaxKind) -> bool2630     fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2631     fn cast(syntax: SyntaxNode) -> Option<Self> {
2632         if Self::can_cast(syntax.kind()) {
2633             Some(Self { syntax })
2634         } else {
2635             None
2636         }
2637     }
syntax(&self) -> &SyntaxNode2638     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2639 }
2640 impl AstNode for PrefixExpr {
can_cast(kind: SyntaxKind) -> bool2641     fn can_cast(kind: SyntaxKind) -> bool { kind == PREFIX_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2642     fn cast(syntax: SyntaxNode) -> Option<Self> {
2643         if Self::can_cast(syntax.kind()) {
2644             Some(Self { syntax })
2645         } else {
2646             None
2647         }
2648     }
syntax(&self) -> &SyntaxNode2649     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2650 }
2651 impl AstNode for RangeExpr {
can_cast(kind: SyntaxKind) -> bool2652     fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2653     fn cast(syntax: SyntaxNode) -> Option<Self> {
2654         if Self::can_cast(syntax.kind()) {
2655             Some(Self { syntax })
2656         } else {
2657             None
2658         }
2659     }
syntax(&self) -> &SyntaxNode2660     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2661 }
2662 impl AstNode for RecordExpr {
can_cast(kind: SyntaxKind) -> bool2663     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2664     fn cast(syntax: SyntaxNode) -> Option<Self> {
2665         if Self::can_cast(syntax.kind()) {
2666             Some(Self { syntax })
2667         } else {
2668             None
2669         }
2670     }
syntax(&self) -> &SyntaxNode2671     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2672 }
2673 impl AstNode for RefExpr {
can_cast(kind: SyntaxKind) -> bool2674     fn can_cast(kind: SyntaxKind) -> bool { kind == REF_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2675     fn cast(syntax: SyntaxNode) -> Option<Self> {
2676         if Self::can_cast(syntax.kind()) {
2677             Some(Self { syntax })
2678         } else {
2679             None
2680         }
2681     }
syntax(&self) -> &SyntaxNode2682     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2683 }
2684 impl AstNode for ReturnExpr {
can_cast(kind: SyntaxKind) -> bool2685     fn can_cast(kind: SyntaxKind) -> bool { kind == RETURN_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2686     fn cast(syntax: SyntaxNode) -> Option<Self> {
2687         if Self::can_cast(syntax.kind()) {
2688             Some(Self { syntax })
2689         } else {
2690             None
2691         }
2692     }
syntax(&self) -> &SyntaxNode2693     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2694 }
2695 impl AstNode for TryExpr {
can_cast(kind: SyntaxKind) -> bool2696     fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2697     fn cast(syntax: SyntaxNode) -> Option<Self> {
2698         if Self::can_cast(syntax.kind()) {
2699             Some(Self { syntax })
2700         } else {
2701             None
2702         }
2703     }
syntax(&self) -> &SyntaxNode2704     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2705 }
2706 impl AstNode for TupleExpr {
can_cast(kind: SyntaxKind) -> bool2707     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2708     fn cast(syntax: SyntaxNode) -> Option<Self> {
2709         if Self::can_cast(syntax.kind()) {
2710             Some(Self { syntax })
2711         } else {
2712             None
2713         }
2714     }
syntax(&self) -> &SyntaxNode2715     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2716 }
2717 impl AstNode for WhileExpr {
can_cast(kind: SyntaxKind) -> bool2718     fn can_cast(kind: SyntaxKind) -> bool { kind == WHILE_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2719     fn cast(syntax: SyntaxNode) -> Option<Self> {
2720         if Self::can_cast(syntax.kind()) {
2721             Some(Self { syntax })
2722         } else {
2723             None
2724         }
2725     }
syntax(&self) -> &SyntaxNode2726     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2727 }
2728 impl AstNode for YieldExpr {
can_cast(kind: SyntaxKind) -> bool2729     fn can_cast(kind: SyntaxKind) -> bool { kind == YIELD_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2730     fn cast(syntax: SyntaxNode) -> Option<Self> {
2731         if Self::can_cast(syntax.kind()) {
2732             Some(Self { syntax })
2733         } else {
2734             None
2735         }
2736     }
syntax(&self) -> &SyntaxNode2737     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2738 }
2739 impl AstNode for YeetExpr {
can_cast(kind: SyntaxKind) -> bool2740     fn can_cast(kind: SyntaxKind) -> bool { kind == YEET_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2741     fn cast(syntax: SyntaxNode) -> Option<Self> {
2742         if Self::can_cast(syntax.kind()) {
2743             Some(Self { syntax })
2744         } else {
2745             None
2746         }
2747     }
syntax(&self) -> &SyntaxNode2748     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2749 }
2750 impl AstNode for LetExpr {
can_cast(kind: SyntaxKind) -> bool2751     fn can_cast(kind: SyntaxKind) -> bool { kind == LET_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2752     fn cast(syntax: SyntaxNode) -> Option<Self> {
2753         if Self::can_cast(syntax.kind()) {
2754             Some(Self { syntax })
2755         } else {
2756             None
2757         }
2758     }
syntax(&self) -> &SyntaxNode2759     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2760 }
2761 impl AstNode for UnderscoreExpr {
can_cast(kind: SyntaxKind) -> bool2762     fn can_cast(kind: SyntaxKind) -> bool { kind == UNDERSCORE_EXPR }
cast(syntax: SyntaxNode) -> Option<Self>2763     fn cast(syntax: SyntaxNode) -> Option<Self> {
2764         if Self::can_cast(syntax.kind()) {
2765             Some(Self { syntax })
2766         } else {
2767             None
2768         }
2769     }
syntax(&self) -> &SyntaxNode2770     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2771 }
2772 impl AstNode for StmtList {
can_cast(kind: SyntaxKind) -> bool2773     fn can_cast(kind: SyntaxKind) -> bool { kind == STMT_LIST }
cast(syntax: SyntaxNode) -> Option<Self>2774     fn cast(syntax: SyntaxNode) -> Option<Self> {
2775         if Self::can_cast(syntax.kind()) {
2776             Some(Self { syntax })
2777         } else {
2778             None
2779         }
2780     }
syntax(&self) -> &SyntaxNode2781     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2782 }
2783 impl AstNode for Label {
can_cast(kind: SyntaxKind) -> bool2784     fn can_cast(kind: SyntaxKind) -> bool { kind == LABEL }
cast(syntax: SyntaxNode) -> Option<Self>2785     fn cast(syntax: SyntaxNode) -> Option<Self> {
2786         if Self::can_cast(syntax.kind()) {
2787             Some(Self { syntax })
2788         } else {
2789             None
2790         }
2791     }
syntax(&self) -> &SyntaxNode2792     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2793 }
2794 impl AstNode for RecordExprFieldList {
can_cast(kind: SyntaxKind) -> bool2795     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD_LIST }
cast(syntax: SyntaxNode) -> Option<Self>2796     fn cast(syntax: SyntaxNode) -> Option<Self> {
2797         if Self::can_cast(syntax.kind()) {
2798             Some(Self { syntax })
2799         } else {
2800             None
2801         }
2802     }
syntax(&self) -> &SyntaxNode2803     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2804 }
2805 impl AstNode for RecordExprField {
can_cast(kind: SyntaxKind) -> bool2806     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD }
cast(syntax: SyntaxNode) -> Option<Self>2807     fn cast(syntax: SyntaxNode) -> Option<Self> {
2808         if Self::can_cast(syntax.kind()) {
2809             Some(Self { syntax })
2810         } else {
2811             None
2812         }
2813     }
syntax(&self) -> &SyntaxNode2814     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2815 }
2816 impl AstNode for ArgList {
can_cast(kind: SyntaxKind) -> bool2817     fn can_cast(kind: SyntaxKind) -> bool { kind == ARG_LIST }
cast(syntax: SyntaxNode) -> Option<Self>2818     fn cast(syntax: SyntaxNode) -> Option<Self> {
2819         if Self::can_cast(syntax.kind()) {
2820             Some(Self { syntax })
2821         } else {
2822             None
2823         }
2824     }
syntax(&self) -> &SyntaxNode2825     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2826 }
2827 impl AstNode for MatchArmList {
can_cast(kind: SyntaxKind) -> bool2828     fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM_LIST }
cast(syntax: SyntaxNode) -> Option<Self>2829     fn cast(syntax: SyntaxNode) -> Option<Self> {
2830         if Self::can_cast(syntax.kind()) {
2831             Some(Self { syntax })
2832         } else {
2833             None
2834         }
2835     }
syntax(&self) -> &SyntaxNode2836     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2837 }
2838 impl AstNode for MatchArm {
can_cast(kind: SyntaxKind) -> bool2839     fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM }
cast(syntax: SyntaxNode) -> Option<Self>2840     fn cast(syntax: SyntaxNode) -> Option<Self> {
2841         if Self::can_cast(syntax.kind()) {
2842             Some(Self { syntax })
2843         } else {
2844             None
2845         }
2846     }
syntax(&self) -> &SyntaxNode2847     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2848 }
2849 impl AstNode for MatchGuard {
can_cast(kind: SyntaxKind) -> bool2850     fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_GUARD }
cast(syntax: SyntaxNode) -> Option<Self>2851     fn cast(syntax: SyntaxNode) -> Option<Self> {
2852         if Self::can_cast(syntax.kind()) {
2853             Some(Self { syntax })
2854         } else {
2855             None
2856         }
2857     }
syntax(&self) -> &SyntaxNode2858     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2859 }
2860 impl AstNode for ArrayType {
can_cast(kind: SyntaxKind) -> bool2861     fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_TYPE }
cast(syntax: SyntaxNode) -> Option<Self>2862     fn cast(syntax: SyntaxNode) -> Option<Self> {
2863         if Self::can_cast(syntax.kind()) {
2864             Some(Self { syntax })
2865         } else {
2866             None
2867         }
2868     }
syntax(&self) -> &SyntaxNode2869     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2870 }
2871 impl AstNode for DynTraitType {
can_cast(kind: SyntaxKind) -> bool2872     fn can_cast(kind: SyntaxKind) -> bool { kind == DYN_TRAIT_TYPE }
cast(syntax: SyntaxNode) -> Option<Self>2873     fn cast(syntax: SyntaxNode) -> Option<Self> {
2874         if Self::can_cast(syntax.kind()) {
2875             Some(Self { syntax })
2876         } else {
2877             None
2878         }
2879     }
syntax(&self) -> &SyntaxNode2880     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2881 }
2882 impl AstNode for FnPtrType {
can_cast(kind: SyntaxKind) -> bool2883     fn can_cast(kind: SyntaxKind) -> bool { kind == FN_PTR_TYPE }
cast(syntax: SyntaxNode) -> Option<Self>2884     fn cast(syntax: SyntaxNode) -> Option<Self> {
2885         if Self::can_cast(syntax.kind()) {
2886             Some(Self { syntax })
2887         } else {
2888             None
2889         }
2890     }
syntax(&self) -> &SyntaxNode2891     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2892 }
2893 impl AstNode for ForType {
can_cast(kind: SyntaxKind) -> bool2894     fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_TYPE }
cast(syntax: SyntaxNode) -> Option<Self>2895     fn cast(syntax: SyntaxNode) -> Option<Self> {
2896         if Self::can_cast(syntax.kind()) {
2897             Some(Self { syntax })
2898         } else {
2899             None
2900         }
2901     }
syntax(&self) -> &SyntaxNode2902     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2903 }
2904 impl AstNode for ImplTraitType {
can_cast(kind: SyntaxKind) -> bool2905     fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_TRAIT_TYPE }
cast(syntax: SyntaxNode) -> Option<Self>2906     fn cast(syntax: SyntaxNode) -> Option<Self> {
2907         if Self::can_cast(syntax.kind()) {
2908             Some(Self { syntax })
2909         } else {
2910             None
2911         }
2912     }
syntax(&self) -> &SyntaxNode2913     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2914 }
2915 impl AstNode for InferType {
can_cast(kind: SyntaxKind) -> bool2916     fn can_cast(kind: SyntaxKind) -> bool { kind == INFER_TYPE }
cast(syntax: SyntaxNode) -> Option<Self>2917     fn cast(syntax: SyntaxNode) -> Option<Self> {
2918         if Self::can_cast(syntax.kind()) {
2919             Some(Self { syntax })
2920         } else {
2921             None
2922         }
2923     }
syntax(&self) -> &SyntaxNode2924     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2925 }
2926 impl AstNode for MacroType {
can_cast(kind: SyntaxKind) -> bool2927     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_TYPE }
cast(syntax: SyntaxNode) -> Option<Self>2928     fn cast(syntax: SyntaxNode) -> Option<Self> {
2929         if Self::can_cast(syntax.kind()) {
2930             Some(Self { syntax })
2931         } else {
2932             None
2933         }
2934     }
syntax(&self) -> &SyntaxNode2935     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2936 }
2937 impl AstNode for NeverType {
can_cast(kind: SyntaxKind) -> bool2938     fn can_cast(kind: SyntaxKind) -> bool { kind == NEVER_TYPE }
cast(syntax: SyntaxNode) -> Option<Self>2939     fn cast(syntax: SyntaxNode) -> Option<Self> {
2940         if Self::can_cast(syntax.kind()) {
2941             Some(Self { syntax })
2942         } else {
2943             None
2944         }
2945     }
syntax(&self) -> &SyntaxNode2946     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2947 }
2948 impl AstNode for ParenType {
can_cast(kind: SyntaxKind) -> bool2949     fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_TYPE }
cast(syntax: SyntaxNode) -> Option<Self>2950     fn cast(syntax: SyntaxNode) -> Option<Self> {
2951         if Self::can_cast(syntax.kind()) {
2952             Some(Self { syntax })
2953         } else {
2954             None
2955         }
2956     }
syntax(&self) -> &SyntaxNode2957     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2958 }
2959 impl AstNode for PtrType {
can_cast(kind: SyntaxKind) -> bool2960     fn can_cast(kind: SyntaxKind) -> bool { kind == PTR_TYPE }
cast(syntax: SyntaxNode) -> Option<Self>2961     fn cast(syntax: SyntaxNode) -> Option<Self> {
2962         if Self::can_cast(syntax.kind()) {
2963             Some(Self { syntax })
2964         } else {
2965             None
2966         }
2967     }
syntax(&self) -> &SyntaxNode2968     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2969 }
2970 impl AstNode for RefType {
can_cast(kind: SyntaxKind) -> bool2971     fn can_cast(kind: SyntaxKind) -> bool { kind == REF_TYPE }
cast(syntax: SyntaxNode) -> Option<Self>2972     fn cast(syntax: SyntaxNode) -> Option<Self> {
2973         if Self::can_cast(syntax.kind()) {
2974             Some(Self { syntax })
2975         } else {
2976             None
2977         }
2978     }
syntax(&self) -> &SyntaxNode2979     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2980 }
2981 impl AstNode for SliceType {
can_cast(kind: SyntaxKind) -> bool2982     fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_TYPE }
cast(syntax: SyntaxNode) -> Option<Self>2983     fn cast(syntax: SyntaxNode) -> Option<Self> {
2984         if Self::can_cast(syntax.kind()) {
2985             Some(Self { syntax })
2986         } else {
2987             None
2988         }
2989     }
syntax(&self) -> &SyntaxNode2990     fn syntax(&self) -> &SyntaxNode { &self.syntax }
2991 }
2992 impl AstNode for TupleType {
can_cast(kind: SyntaxKind) -> bool2993     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_TYPE }
cast(syntax: SyntaxNode) -> Option<Self>2994     fn cast(syntax: SyntaxNode) -> Option<Self> {
2995         if Self::can_cast(syntax.kind()) {
2996             Some(Self { syntax })
2997         } else {
2998             None
2999         }
3000     }
syntax(&self) -> &SyntaxNode3001     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3002 }
3003 impl AstNode for TypeBound {
can_cast(kind: SyntaxKind) -> bool3004     fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND }
cast(syntax: SyntaxNode) -> Option<Self>3005     fn cast(syntax: SyntaxNode) -> Option<Self> {
3006         if Self::can_cast(syntax.kind()) {
3007             Some(Self { syntax })
3008         } else {
3009             None
3010         }
3011     }
syntax(&self) -> &SyntaxNode3012     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3013 }
3014 impl AstNode for IdentPat {
can_cast(kind: SyntaxKind) -> bool3015     fn can_cast(kind: SyntaxKind) -> bool { kind == IDENT_PAT }
cast(syntax: SyntaxNode) -> Option<Self>3016     fn cast(syntax: SyntaxNode) -> Option<Self> {
3017         if Self::can_cast(syntax.kind()) {
3018             Some(Self { syntax })
3019         } else {
3020             None
3021         }
3022     }
syntax(&self) -> &SyntaxNode3023     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3024 }
3025 impl AstNode for BoxPat {
can_cast(kind: SyntaxKind) -> bool3026     fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_PAT }
cast(syntax: SyntaxNode) -> Option<Self>3027     fn cast(syntax: SyntaxNode) -> Option<Self> {
3028         if Self::can_cast(syntax.kind()) {
3029             Some(Self { syntax })
3030         } else {
3031             None
3032         }
3033     }
syntax(&self) -> &SyntaxNode3034     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3035 }
3036 impl AstNode for RestPat {
can_cast(kind: SyntaxKind) -> bool3037     fn can_cast(kind: SyntaxKind) -> bool { kind == REST_PAT }
cast(syntax: SyntaxNode) -> Option<Self>3038     fn cast(syntax: SyntaxNode) -> Option<Self> {
3039         if Self::can_cast(syntax.kind()) {
3040             Some(Self { syntax })
3041         } else {
3042             None
3043         }
3044     }
syntax(&self) -> &SyntaxNode3045     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3046 }
3047 impl AstNode for LiteralPat {
can_cast(kind: SyntaxKind) -> bool3048     fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL_PAT }
cast(syntax: SyntaxNode) -> Option<Self>3049     fn cast(syntax: SyntaxNode) -> Option<Self> {
3050         if Self::can_cast(syntax.kind()) {
3051             Some(Self { syntax })
3052         } else {
3053             None
3054         }
3055     }
syntax(&self) -> &SyntaxNode3056     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3057 }
3058 impl AstNode for MacroPat {
can_cast(kind: SyntaxKind) -> bool3059     fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_PAT }
cast(syntax: SyntaxNode) -> Option<Self>3060     fn cast(syntax: SyntaxNode) -> Option<Self> {
3061         if Self::can_cast(syntax.kind()) {
3062             Some(Self { syntax })
3063         } else {
3064             None
3065         }
3066     }
syntax(&self) -> &SyntaxNode3067     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3068 }
3069 impl AstNode for OrPat {
can_cast(kind: SyntaxKind) -> bool3070     fn can_cast(kind: SyntaxKind) -> bool { kind == OR_PAT }
cast(syntax: SyntaxNode) -> Option<Self>3071     fn cast(syntax: SyntaxNode) -> Option<Self> {
3072         if Self::can_cast(syntax.kind()) {
3073             Some(Self { syntax })
3074         } else {
3075             None
3076         }
3077     }
syntax(&self) -> &SyntaxNode3078     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3079 }
3080 impl AstNode for ParenPat {
can_cast(kind: SyntaxKind) -> bool3081     fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_PAT }
cast(syntax: SyntaxNode) -> Option<Self>3082     fn cast(syntax: SyntaxNode) -> Option<Self> {
3083         if Self::can_cast(syntax.kind()) {
3084             Some(Self { syntax })
3085         } else {
3086             None
3087         }
3088     }
syntax(&self) -> &SyntaxNode3089     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3090 }
3091 impl AstNode for PathPat {
can_cast(kind: SyntaxKind) -> bool3092     fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_PAT }
cast(syntax: SyntaxNode) -> Option<Self>3093     fn cast(syntax: SyntaxNode) -> Option<Self> {
3094         if Self::can_cast(syntax.kind()) {
3095             Some(Self { syntax })
3096         } else {
3097             None
3098         }
3099     }
syntax(&self) -> &SyntaxNode3100     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3101 }
3102 impl AstNode for WildcardPat {
can_cast(kind: SyntaxKind) -> bool3103     fn can_cast(kind: SyntaxKind) -> bool { kind == WILDCARD_PAT }
cast(syntax: SyntaxNode) -> Option<Self>3104     fn cast(syntax: SyntaxNode) -> Option<Self> {
3105         if Self::can_cast(syntax.kind()) {
3106             Some(Self { syntax })
3107         } else {
3108             None
3109         }
3110     }
syntax(&self) -> &SyntaxNode3111     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3112 }
3113 impl AstNode for RangePat {
can_cast(kind: SyntaxKind) -> bool3114     fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_PAT }
cast(syntax: SyntaxNode) -> Option<Self>3115     fn cast(syntax: SyntaxNode) -> Option<Self> {
3116         if Self::can_cast(syntax.kind()) {
3117             Some(Self { syntax })
3118         } else {
3119             None
3120         }
3121     }
syntax(&self) -> &SyntaxNode3122     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3123 }
3124 impl AstNode for RecordPat {
can_cast(kind: SyntaxKind) -> bool3125     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT }
cast(syntax: SyntaxNode) -> Option<Self>3126     fn cast(syntax: SyntaxNode) -> Option<Self> {
3127         if Self::can_cast(syntax.kind()) {
3128             Some(Self { syntax })
3129         } else {
3130             None
3131         }
3132     }
syntax(&self) -> &SyntaxNode3133     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3134 }
3135 impl AstNode for RefPat {
can_cast(kind: SyntaxKind) -> bool3136     fn can_cast(kind: SyntaxKind) -> bool { kind == REF_PAT }
cast(syntax: SyntaxNode) -> Option<Self>3137     fn cast(syntax: SyntaxNode) -> Option<Self> {
3138         if Self::can_cast(syntax.kind()) {
3139             Some(Self { syntax })
3140         } else {
3141             None
3142         }
3143     }
syntax(&self) -> &SyntaxNode3144     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3145 }
3146 impl AstNode for SlicePat {
can_cast(kind: SyntaxKind) -> bool3147     fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_PAT }
cast(syntax: SyntaxNode) -> Option<Self>3148     fn cast(syntax: SyntaxNode) -> Option<Self> {
3149         if Self::can_cast(syntax.kind()) {
3150             Some(Self { syntax })
3151         } else {
3152             None
3153         }
3154     }
syntax(&self) -> &SyntaxNode3155     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3156 }
3157 impl AstNode for TuplePat {
can_cast(kind: SyntaxKind) -> bool3158     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_PAT }
cast(syntax: SyntaxNode) -> Option<Self>3159     fn cast(syntax: SyntaxNode) -> Option<Self> {
3160         if Self::can_cast(syntax.kind()) {
3161             Some(Self { syntax })
3162         } else {
3163             None
3164         }
3165     }
syntax(&self) -> &SyntaxNode3166     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3167 }
3168 impl AstNode for TupleStructPat {
can_cast(kind: SyntaxKind) -> bool3169     fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_STRUCT_PAT }
cast(syntax: SyntaxNode) -> Option<Self>3170     fn cast(syntax: SyntaxNode) -> Option<Self> {
3171         if Self::can_cast(syntax.kind()) {
3172             Some(Self { syntax })
3173         } else {
3174             None
3175         }
3176     }
syntax(&self) -> &SyntaxNode3177     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3178 }
3179 impl AstNode for ConstBlockPat {
can_cast(kind: SyntaxKind) -> bool3180     fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_BLOCK_PAT }
cast(syntax: SyntaxNode) -> Option<Self>3181     fn cast(syntax: SyntaxNode) -> Option<Self> {
3182         if Self::can_cast(syntax.kind()) {
3183             Some(Self { syntax })
3184         } else {
3185             None
3186         }
3187     }
syntax(&self) -> &SyntaxNode3188     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3189 }
3190 impl AstNode for RecordPatFieldList {
can_cast(kind: SyntaxKind) -> bool3191     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD_LIST }
cast(syntax: SyntaxNode) -> Option<Self>3192     fn cast(syntax: SyntaxNode) -> Option<Self> {
3193         if Self::can_cast(syntax.kind()) {
3194             Some(Self { syntax })
3195         } else {
3196             None
3197         }
3198     }
syntax(&self) -> &SyntaxNode3199     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3200 }
3201 impl AstNode for RecordPatField {
can_cast(kind: SyntaxKind) -> bool3202     fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD }
cast(syntax: SyntaxNode) -> Option<Self>3203     fn cast(syntax: SyntaxNode) -> Option<Self> {
3204         if Self::can_cast(syntax.kind()) {
3205             Some(Self { syntax })
3206         } else {
3207             None
3208         }
3209     }
syntax(&self) -> &SyntaxNode3210     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3211 }
3212 impl From<TypeArg> for GenericArg {
from(node: TypeArg) -> GenericArg3213     fn from(node: TypeArg) -> GenericArg { GenericArg::TypeArg(node) }
3214 }
3215 impl From<AssocTypeArg> for GenericArg {
from(node: AssocTypeArg) -> GenericArg3216     fn from(node: AssocTypeArg) -> GenericArg { GenericArg::AssocTypeArg(node) }
3217 }
3218 impl From<LifetimeArg> for GenericArg {
from(node: LifetimeArg) -> GenericArg3219     fn from(node: LifetimeArg) -> GenericArg { GenericArg::LifetimeArg(node) }
3220 }
3221 impl From<ConstArg> for GenericArg {
from(node: ConstArg) -> GenericArg3222     fn from(node: ConstArg) -> GenericArg { GenericArg::ConstArg(node) }
3223 }
3224 impl AstNode for GenericArg {
can_cast(kind: SyntaxKind) -> bool3225     fn can_cast(kind: SyntaxKind) -> bool {
3226         matches!(kind, TYPE_ARG | ASSOC_TYPE_ARG | LIFETIME_ARG | CONST_ARG)
3227     }
cast(syntax: SyntaxNode) -> Option<Self>3228     fn cast(syntax: SyntaxNode) -> Option<Self> {
3229         let res = match syntax.kind() {
3230             TYPE_ARG => GenericArg::TypeArg(TypeArg { syntax }),
3231             ASSOC_TYPE_ARG => GenericArg::AssocTypeArg(AssocTypeArg { syntax }),
3232             LIFETIME_ARG => GenericArg::LifetimeArg(LifetimeArg { syntax }),
3233             CONST_ARG => GenericArg::ConstArg(ConstArg { syntax }),
3234             _ => return None,
3235         };
3236         Some(res)
3237     }
syntax(&self) -> &SyntaxNode3238     fn syntax(&self) -> &SyntaxNode {
3239         match self {
3240             GenericArg::TypeArg(it) => &it.syntax,
3241             GenericArg::AssocTypeArg(it) => &it.syntax,
3242             GenericArg::LifetimeArg(it) => &it.syntax,
3243             GenericArg::ConstArg(it) => &it.syntax,
3244         }
3245     }
3246 }
3247 impl From<ArrayType> for Type {
from(node: ArrayType) -> Type3248     fn from(node: ArrayType) -> Type { Type::ArrayType(node) }
3249 }
3250 impl From<DynTraitType> for Type {
from(node: DynTraitType) -> Type3251     fn from(node: DynTraitType) -> Type { Type::DynTraitType(node) }
3252 }
3253 impl From<FnPtrType> for Type {
from(node: FnPtrType) -> Type3254     fn from(node: FnPtrType) -> Type { Type::FnPtrType(node) }
3255 }
3256 impl From<ForType> for Type {
from(node: ForType) -> Type3257     fn from(node: ForType) -> Type { Type::ForType(node) }
3258 }
3259 impl From<ImplTraitType> for Type {
from(node: ImplTraitType) -> Type3260     fn from(node: ImplTraitType) -> Type { Type::ImplTraitType(node) }
3261 }
3262 impl From<InferType> for Type {
from(node: InferType) -> Type3263     fn from(node: InferType) -> Type { Type::InferType(node) }
3264 }
3265 impl From<MacroType> for Type {
from(node: MacroType) -> Type3266     fn from(node: MacroType) -> Type { Type::MacroType(node) }
3267 }
3268 impl From<NeverType> for Type {
from(node: NeverType) -> Type3269     fn from(node: NeverType) -> Type { Type::NeverType(node) }
3270 }
3271 impl From<ParenType> for Type {
from(node: ParenType) -> Type3272     fn from(node: ParenType) -> Type { Type::ParenType(node) }
3273 }
3274 impl From<PathType> for Type {
from(node: PathType) -> Type3275     fn from(node: PathType) -> Type { Type::PathType(node) }
3276 }
3277 impl From<PtrType> for Type {
from(node: PtrType) -> Type3278     fn from(node: PtrType) -> Type { Type::PtrType(node) }
3279 }
3280 impl From<RefType> for Type {
from(node: RefType) -> Type3281     fn from(node: RefType) -> Type { Type::RefType(node) }
3282 }
3283 impl From<SliceType> for Type {
from(node: SliceType) -> Type3284     fn from(node: SliceType) -> Type { Type::SliceType(node) }
3285 }
3286 impl From<TupleType> for Type {
from(node: TupleType) -> Type3287     fn from(node: TupleType) -> Type { Type::TupleType(node) }
3288 }
3289 impl AstNode for Type {
can_cast(kind: SyntaxKind) -> bool3290     fn can_cast(kind: SyntaxKind) -> bool {
3291         matches!(
3292             kind,
3293             ARRAY_TYPE
3294                 | DYN_TRAIT_TYPE
3295                 | FN_PTR_TYPE
3296                 | FOR_TYPE
3297                 | IMPL_TRAIT_TYPE
3298                 | INFER_TYPE
3299                 | MACRO_TYPE
3300                 | NEVER_TYPE
3301                 | PAREN_TYPE
3302                 | PATH_TYPE
3303                 | PTR_TYPE
3304                 | REF_TYPE
3305                 | SLICE_TYPE
3306                 | TUPLE_TYPE
3307         )
3308     }
cast(syntax: SyntaxNode) -> Option<Self>3309     fn cast(syntax: SyntaxNode) -> Option<Self> {
3310         let res = match syntax.kind() {
3311             ARRAY_TYPE => Type::ArrayType(ArrayType { syntax }),
3312             DYN_TRAIT_TYPE => Type::DynTraitType(DynTraitType { syntax }),
3313             FN_PTR_TYPE => Type::FnPtrType(FnPtrType { syntax }),
3314             FOR_TYPE => Type::ForType(ForType { syntax }),
3315             IMPL_TRAIT_TYPE => Type::ImplTraitType(ImplTraitType { syntax }),
3316             INFER_TYPE => Type::InferType(InferType { syntax }),
3317             MACRO_TYPE => Type::MacroType(MacroType { syntax }),
3318             NEVER_TYPE => Type::NeverType(NeverType { syntax }),
3319             PAREN_TYPE => Type::ParenType(ParenType { syntax }),
3320             PATH_TYPE => Type::PathType(PathType { syntax }),
3321             PTR_TYPE => Type::PtrType(PtrType { syntax }),
3322             REF_TYPE => Type::RefType(RefType { syntax }),
3323             SLICE_TYPE => Type::SliceType(SliceType { syntax }),
3324             TUPLE_TYPE => Type::TupleType(TupleType { syntax }),
3325             _ => return None,
3326         };
3327         Some(res)
3328     }
syntax(&self) -> &SyntaxNode3329     fn syntax(&self) -> &SyntaxNode {
3330         match self {
3331             Type::ArrayType(it) => &it.syntax,
3332             Type::DynTraitType(it) => &it.syntax,
3333             Type::FnPtrType(it) => &it.syntax,
3334             Type::ForType(it) => &it.syntax,
3335             Type::ImplTraitType(it) => &it.syntax,
3336             Type::InferType(it) => &it.syntax,
3337             Type::MacroType(it) => &it.syntax,
3338             Type::NeverType(it) => &it.syntax,
3339             Type::ParenType(it) => &it.syntax,
3340             Type::PathType(it) => &it.syntax,
3341             Type::PtrType(it) => &it.syntax,
3342             Type::RefType(it) => &it.syntax,
3343             Type::SliceType(it) => &it.syntax,
3344             Type::TupleType(it) => &it.syntax,
3345         }
3346     }
3347 }
3348 impl From<ArrayExpr> for Expr {
from(node: ArrayExpr) -> Expr3349     fn from(node: ArrayExpr) -> Expr { Expr::ArrayExpr(node) }
3350 }
3351 impl From<AwaitExpr> for Expr {
from(node: AwaitExpr) -> Expr3352     fn from(node: AwaitExpr) -> Expr { Expr::AwaitExpr(node) }
3353 }
3354 impl From<BinExpr> for Expr {
from(node: BinExpr) -> Expr3355     fn from(node: BinExpr) -> Expr { Expr::BinExpr(node) }
3356 }
3357 impl From<BlockExpr> for Expr {
from(node: BlockExpr) -> Expr3358     fn from(node: BlockExpr) -> Expr { Expr::BlockExpr(node) }
3359 }
3360 impl From<BoxExpr> for Expr {
from(node: BoxExpr) -> Expr3361     fn from(node: BoxExpr) -> Expr { Expr::BoxExpr(node) }
3362 }
3363 impl From<BreakExpr> for Expr {
from(node: BreakExpr) -> Expr3364     fn from(node: BreakExpr) -> Expr { Expr::BreakExpr(node) }
3365 }
3366 impl From<CallExpr> for Expr {
from(node: CallExpr) -> Expr3367     fn from(node: CallExpr) -> Expr { Expr::CallExpr(node) }
3368 }
3369 impl From<CastExpr> for Expr {
from(node: CastExpr) -> Expr3370     fn from(node: CastExpr) -> Expr { Expr::CastExpr(node) }
3371 }
3372 impl From<ClosureExpr> for Expr {
from(node: ClosureExpr) -> Expr3373     fn from(node: ClosureExpr) -> Expr { Expr::ClosureExpr(node) }
3374 }
3375 impl From<ContinueExpr> for Expr {
from(node: ContinueExpr) -> Expr3376     fn from(node: ContinueExpr) -> Expr { Expr::ContinueExpr(node) }
3377 }
3378 impl From<FieldExpr> for Expr {
from(node: FieldExpr) -> Expr3379     fn from(node: FieldExpr) -> Expr { Expr::FieldExpr(node) }
3380 }
3381 impl From<ForExpr> for Expr {
from(node: ForExpr) -> Expr3382     fn from(node: ForExpr) -> Expr { Expr::ForExpr(node) }
3383 }
3384 impl From<IfExpr> for Expr {
from(node: IfExpr) -> Expr3385     fn from(node: IfExpr) -> Expr { Expr::IfExpr(node) }
3386 }
3387 impl From<IndexExpr> for Expr {
from(node: IndexExpr) -> Expr3388     fn from(node: IndexExpr) -> Expr { Expr::IndexExpr(node) }
3389 }
3390 impl From<Literal> for Expr {
from(node: Literal) -> Expr3391     fn from(node: Literal) -> Expr { Expr::Literal(node) }
3392 }
3393 impl From<LoopExpr> for Expr {
from(node: LoopExpr) -> Expr3394     fn from(node: LoopExpr) -> Expr { Expr::LoopExpr(node) }
3395 }
3396 impl From<MacroExpr> for Expr {
from(node: MacroExpr) -> Expr3397     fn from(node: MacroExpr) -> Expr { Expr::MacroExpr(node) }
3398 }
3399 impl From<MatchExpr> for Expr {
from(node: MatchExpr) -> Expr3400     fn from(node: MatchExpr) -> Expr { Expr::MatchExpr(node) }
3401 }
3402 impl From<MethodCallExpr> for Expr {
from(node: MethodCallExpr) -> Expr3403     fn from(node: MethodCallExpr) -> Expr { Expr::MethodCallExpr(node) }
3404 }
3405 impl From<ParenExpr> for Expr {
from(node: ParenExpr) -> Expr3406     fn from(node: ParenExpr) -> Expr { Expr::ParenExpr(node) }
3407 }
3408 impl From<PathExpr> for Expr {
from(node: PathExpr) -> Expr3409     fn from(node: PathExpr) -> Expr { Expr::PathExpr(node) }
3410 }
3411 impl From<PrefixExpr> for Expr {
from(node: PrefixExpr) -> Expr3412     fn from(node: PrefixExpr) -> Expr { Expr::PrefixExpr(node) }
3413 }
3414 impl From<RangeExpr> for Expr {
from(node: RangeExpr) -> Expr3415     fn from(node: RangeExpr) -> Expr { Expr::RangeExpr(node) }
3416 }
3417 impl From<RecordExpr> for Expr {
from(node: RecordExpr) -> Expr3418     fn from(node: RecordExpr) -> Expr { Expr::RecordExpr(node) }
3419 }
3420 impl From<RefExpr> for Expr {
from(node: RefExpr) -> Expr3421     fn from(node: RefExpr) -> Expr { Expr::RefExpr(node) }
3422 }
3423 impl From<ReturnExpr> for Expr {
from(node: ReturnExpr) -> Expr3424     fn from(node: ReturnExpr) -> Expr { Expr::ReturnExpr(node) }
3425 }
3426 impl From<TryExpr> for Expr {
from(node: TryExpr) -> Expr3427     fn from(node: TryExpr) -> Expr { Expr::TryExpr(node) }
3428 }
3429 impl From<TupleExpr> for Expr {
from(node: TupleExpr) -> Expr3430     fn from(node: TupleExpr) -> Expr { Expr::TupleExpr(node) }
3431 }
3432 impl From<WhileExpr> for Expr {
from(node: WhileExpr) -> Expr3433     fn from(node: WhileExpr) -> Expr { Expr::WhileExpr(node) }
3434 }
3435 impl From<YieldExpr> for Expr {
from(node: YieldExpr) -> Expr3436     fn from(node: YieldExpr) -> Expr { Expr::YieldExpr(node) }
3437 }
3438 impl From<YeetExpr> for Expr {
from(node: YeetExpr) -> Expr3439     fn from(node: YeetExpr) -> Expr { Expr::YeetExpr(node) }
3440 }
3441 impl From<LetExpr> for Expr {
from(node: LetExpr) -> Expr3442     fn from(node: LetExpr) -> Expr { Expr::LetExpr(node) }
3443 }
3444 impl From<UnderscoreExpr> for Expr {
from(node: UnderscoreExpr) -> Expr3445     fn from(node: UnderscoreExpr) -> Expr { Expr::UnderscoreExpr(node) }
3446 }
3447 impl AstNode for Expr {
can_cast(kind: SyntaxKind) -> bool3448     fn can_cast(kind: SyntaxKind) -> bool {
3449         matches!(
3450             kind,
3451             ARRAY_EXPR
3452                 | AWAIT_EXPR
3453                 | BIN_EXPR
3454                 | BLOCK_EXPR
3455                 | BOX_EXPR
3456                 | BREAK_EXPR
3457                 | CALL_EXPR
3458                 | CAST_EXPR
3459                 | CLOSURE_EXPR
3460                 | CONTINUE_EXPR
3461                 | FIELD_EXPR
3462                 | FOR_EXPR
3463                 | IF_EXPR
3464                 | INDEX_EXPR
3465                 | LITERAL
3466                 | LOOP_EXPR
3467                 | MACRO_EXPR
3468                 | MATCH_EXPR
3469                 | METHOD_CALL_EXPR
3470                 | PAREN_EXPR
3471                 | PATH_EXPR
3472                 | PREFIX_EXPR
3473                 | RANGE_EXPR
3474                 | RECORD_EXPR
3475                 | REF_EXPR
3476                 | RETURN_EXPR
3477                 | TRY_EXPR
3478                 | TUPLE_EXPR
3479                 | WHILE_EXPR
3480                 | YIELD_EXPR
3481                 | YEET_EXPR
3482                 | LET_EXPR
3483                 | UNDERSCORE_EXPR
3484         )
3485     }
cast(syntax: SyntaxNode) -> Option<Self>3486     fn cast(syntax: SyntaxNode) -> Option<Self> {
3487         let res = match syntax.kind() {
3488             ARRAY_EXPR => Expr::ArrayExpr(ArrayExpr { syntax }),
3489             AWAIT_EXPR => Expr::AwaitExpr(AwaitExpr { syntax }),
3490             BIN_EXPR => Expr::BinExpr(BinExpr { syntax }),
3491             BLOCK_EXPR => Expr::BlockExpr(BlockExpr { syntax }),
3492             BOX_EXPR => Expr::BoxExpr(BoxExpr { syntax }),
3493             BREAK_EXPR => Expr::BreakExpr(BreakExpr { syntax }),
3494             CALL_EXPR => Expr::CallExpr(CallExpr { syntax }),
3495             CAST_EXPR => Expr::CastExpr(CastExpr { syntax }),
3496             CLOSURE_EXPR => Expr::ClosureExpr(ClosureExpr { syntax }),
3497             CONTINUE_EXPR => Expr::ContinueExpr(ContinueExpr { syntax }),
3498             FIELD_EXPR => Expr::FieldExpr(FieldExpr { syntax }),
3499             FOR_EXPR => Expr::ForExpr(ForExpr { syntax }),
3500             IF_EXPR => Expr::IfExpr(IfExpr { syntax }),
3501             INDEX_EXPR => Expr::IndexExpr(IndexExpr { syntax }),
3502             LITERAL => Expr::Literal(Literal { syntax }),
3503             LOOP_EXPR => Expr::LoopExpr(LoopExpr { syntax }),
3504             MACRO_EXPR => Expr::MacroExpr(MacroExpr { syntax }),
3505             MATCH_EXPR => Expr::MatchExpr(MatchExpr { syntax }),
3506             METHOD_CALL_EXPR => Expr::MethodCallExpr(MethodCallExpr { syntax }),
3507             PAREN_EXPR => Expr::ParenExpr(ParenExpr { syntax }),
3508             PATH_EXPR => Expr::PathExpr(PathExpr { syntax }),
3509             PREFIX_EXPR => Expr::PrefixExpr(PrefixExpr { syntax }),
3510             RANGE_EXPR => Expr::RangeExpr(RangeExpr { syntax }),
3511             RECORD_EXPR => Expr::RecordExpr(RecordExpr { syntax }),
3512             REF_EXPR => Expr::RefExpr(RefExpr { syntax }),
3513             RETURN_EXPR => Expr::ReturnExpr(ReturnExpr { syntax }),
3514             TRY_EXPR => Expr::TryExpr(TryExpr { syntax }),
3515             TUPLE_EXPR => Expr::TupleExpr(TupleExpr { syntax }),
3516             WHILE_EXPR => Expr::WhileExpr(WhileExpr { syntax }),
3517             YIELD_EXPR => Expr::YieldExpr(YieldExpr { syntax }),
3518             YEET_EXPR => Expr::YeetExpr(YeetExpr { syntax }),
3519             LET_EXPR => Expr::LetExpr(LetExpr { syntax }),
3520             UNDERSCORE_EXPR => Expr::UnderscoreExpr(UnderscoreExpr { syntax }),
3521             _ => return None,
3522         };
3523         Some(res)
3524     }
syntax(&self) -> &SyntaxNode3525     fn syntax(&self) -> &SyntaxNode {
3526         match self {
3527             Expr::ArrayExpr(it) => &it.syntax,
3528             Expr::AwaitExpr(it) => &it.syntax,
3529             Expr::BinExpr(it) => &it.syntax,
3530             Expr::BlockExpr(it) => &it.syntax,
3531             Expr::BoxExpr(it) => &it.syntax,
3532             Expr::BreakExpr(it) => &it.syntax,
3533             Expr::CallExpr(it) => &it.syntax,
3534             Expr::CastExpr(it) => &it.syntax,
3535             Expr::ClosureExpr(it) => &it.syntax,
3536             Expr::ContinueExpr(it) => &it.syntax,
3537             Expr::FieldExpr(it) => &it.syntax,
3538             Expr::ForExpr(it) => &it.syntax,
3539             Expr::IfExpr(it) => &it.syntax,
3540             Expr::IndexExpr(it) => &it.syntax,
3541             Expr::Literal(it) => &it.syntax,
3542             Expr::LoopExpr(it) => &it.syntax,
3543             Expr::MacroExpr(it) => &it.syntax,
3544             Expr::MatchExpr(it) => &it.syntax,
3545             Expr::MethodCallExpr(it) => &it.syntax,
3546             Expr::ParenExpr(it) => &it.syntax,
3547             Expr::PathExpr(it) => &it.syntax,
3548             Expr::PrefixExpr(it) => &it.syntax,
3549             Expr::RangeExpr(it) => &it.syntax,
3550             Expr::RecordExpr(it) => &it.syntax,
3551             Expr::RefExpr(it) => &it.syntax,
3552             Expr::ReturnExpr(it) => &it.syntax,
3553             Expr::TryExpr(it) => &it.syntax,
3554             Expr::TupleExpr(it) => &it.syntax,
3555             Expr::WhileExpr(it) => &it.syntax,
3556             Expr::YieldExpr(it) => &it.syntax,
3557             Expr::YeetExpr(it) => &it.syntax,
3558             Expr::LetExpr(it) => &it.syntax,
3559             Expr::UnderscoreExpr(it) => &it.syntax,
3560         }
3561     }
3562 }
3563 impl From<Const> for Item {
from(node: Const) -> Item3564     fn from(node: Const) -> Item { Item::Const(node) }
3565 }
3566 impl From<Enum> for Item {
from(node: Enum) -> Item3567     fn from(node: Enum) -> Item { Item::Enum(node) }
3568 }
3569 impl From<ExternBlock> for Item {
from(node: ExternBlock) -> Item3570     fn from(node: ExternBlock) -> Item { Item::ExternBlock(node) }
3571 }
3572 impl From<ExternCrate> for Item {
from(node: ExternCrate) -> Item3573     fn from(node: ExternCrate) -> Item { Item::ExternCrate(node) }
3574 }
3575 impl From<Fn> for Item {
from(node: Fn) -> Item3576     fn from(node: Fn) -> Item { Item::Fn(node) }
3577 }
3578 impl From<Impl> for Item {
from(node: Impl) -> Item3579     fn from(node: Impl) -> Item { Item::Impl(node) }
3580 }
3581 impl From<MacroCall> for Item {
from(node: MacroCall) -> Item3582     fn from(node: MacroCall) -> Item { Item::MacroCall(node) }
3583 }
3584 impl From<MacroRules> for Item {
from(node: MacroRules) -> Item3585     fn from(node: MacroRules) -> Item { Item::MacroRules(node) }
3586 }
3587 impl From<MacroDef> for Item {
from(node: MacroDef) -> Item3588     fn from(node: MacroDef) -> Item { Item::MacroDef(node) }
3589 }
3590 impl From<Module> for Item {
from(node: Module) -> Item3591     fn from(node: Module) -> Item { Item::Module(node) }
3592 }
3593 impl From<Static> for Item {
from(node: Static) -> Item3594     fn from(node: Static) -> Item { Item::Static(node) }
3595 }
3596 impl From<Struct> for Item {
from(node: Struct) -> Item3597     fn from(node: Struct) -> Item { Item::Struct(node) }
3598 }
3599 impl From<Trait> for Item {
from(node: Trait) -> Item3600     fn from(node: Trait) -> Item { Item::Trait(node) }
3601 }
3602 impl From<TraitAlias> for Item {
from(node: TraitAlias) -> Item3603     fn from(node: TraitAlias) -> Item { Item::TraitAlias(node) }
3604 }
3605 impl From<TypeAlias> for Item {
from(node: TypeAlias) -> Item3606     fn from(node: TypeAlias) -> Item { Item::TypeAlias(node) }
3607 }
3608 impl From<Union> for Item {
from(node: Union) -> Item3609     fn from(node: Union) -> Item { Item::Union(node) }
3610 }
3611 impl From<Use> for Item {
from(node: Use) -> Item3612     fn from(node: Use) -> Item { Item::Use(node) }
3613 }
3614 impl AstNode for Item {
can_cast(kind: SyntaxKind) -> bool3615     fn can_cast(kind: SyntaxKind) -> bool {
3616         matches!(
3617             kind,
3618             CONST
3619                 | ENUM
3620                 | EXTERN_BLOCK
3621                 | EXTERN_CRATE
3622                 | FN
3623                 | IMPL
3624                 | MACRO_CALL
3625                 | MACRO_RULES
3626                 | MACRO_DEF
3627                 | MODULE
3628                 | STATIC
3629                 | STRUCT
3630                 | TRAIT
3631                 | TRAIT_ALIAS
3632                 | TYPE_ALIAS
3633                 | UNION
3634                 | USE
3635         )
3636     }
cast(syntax: SyntaxNode) -> Option<Self>3637     fn cast(syntax: SyntaxNode) -> Option<Self> {
3638         let res = match syntax.kind() {
3639             CONST => Item::Const(Const { syntax }),
3640             ENUM => Item::Enum(Enum { syntax }),
3641             EXTERN_BLOCK => Item::ExternBlock(ExternBlock { syntax }),
3642             EXTERN_CRATE => Item::ExternCrate(ExternCrate { syntax }),
3643             FN => Item::Fn(Fn { syntax }),
3644             IMPL => Item::Impl(Impl { syntax }),
3645             MACRO_CALL => Item::MacroCall(MacroCall { syntax }),
3646             MACRO_RULES => Item::MacroRules(MacroRules { syntax }),
3647             MACRO_DEF => Item::MacroDef(MacroDef { syntax }),
3648             MODULE => Item::Module(Module { syntax }),
3649             STATIC => Item::Static(Static { syntax }),
3650             STRUCT => Item::Struct(Struct { syntax }),
3651             TRAIT => Item::Trait(Trait { syntax }),
3652             TRAIT_ALIAS => Item::TraitAlias(TraitAlias { syntax }),
3653             TYPE_ALIAS => Item::TypeAlias(TypeAlias { syntax }),
3654             UNION => Item::Union(Union { syntax }),
3655             USE => Item::Use(Use { syntax }),
3656             _ => return None,
3657         };
3658         Some(res)
3659     }
syntax(&self) -> &SyntaxNode3660     fn syntax(&self) -> &SyntaxNode {
3661         match self {
3662             Item::Const(it) => &it.syntax,
3663             Item::Enum(it) => &it.syntax,
3664             Item::ExternBlock(it) => &it.syntax,
3665             Item::ExternCrate(it) => &it.syntax,
3666             Item::Fn(it) => &it.syntax,
3667             Item::Impl(it) => &it.syntax,
3668             Item::MacroCall(it) => &it.syntax,
3669             Item::MacroRules(it) => &it.syntax,
3670             Item::MacroDef(it) => &it.syntax,
3671             Item::Module(it) => &it.syntax,
3672             Item::Static(it) => &it.syntax,
3673             Item::Struct(it) => &it.syntax,
3674             Item::Trait(it) => &it.syntax,
3675             Item::TraitAlias(it) => &it.syntax,
3676             Item::TypeAlias(it) => &it.syntax,
3677             Item::Union(it) => &it.syntax,
3678             Item::Use(it) => &it.syntax,
3679         }
3680     }
3681 }
3682 impl From<ExprStmt> for Stmt {
from(node: ExprStmt) -> Stmt3683     fn from(node: ExprStmt) -> Stmt { Stmt::ExprStmt(node) }
3684 }
3685 impl From<Item> for Stmt {
from(node: Item) -> Stmt3686     fn from(node: Item) -> Stmt { Stmt::Item(node) }
3687 }
3688 impl From<LetStmt> for Stmt {
from(node: LetStmt) -> Stmt3689     fn from(node: LetStmt) -> Stmt { Stmt::LetStmt(node) }
3690 }
3691 impl From<IdentPat> for Pat {
from(node: IdentPat) -> Pat3692     fn from(node: IdentPat) -> Pat { Pat::IdentPat(node) }
3693 }
3694 impl From<BoxPat> for Pat {
from(node: BoxPat) -> Pat3695     fn from(node: BoxPat) -> Pat { Pat::BoxPat(node) }
3696 }
3697 impl From<RestPat> for Pat {
from(node: RestPat) -> Pat3698     fn from(node: RestPat) -> Pat { Pat::RestPat(node) }
3699 }
3700 impl From<LiteralPat> for Pat {
from(node: LiteralPat) -> Pat3701     fn from(node: LiteralPat) -> Pat { Pat::LiteralPat(node) }
3702 }
3703 impl From<MacroPat> for Pat {
from(node: MacroPat) -> Pat3704     fn from(node: MacroPat) -> Pat { Pat::MacroPat(node) }
3705 }
3706 impl From<OrPat> for Pat {
from(node: OrPat) -> Pat3707     fn from(node: OrPat) -> Pat { Pat::OrPat(node) }
3708 }
3709 impl From<ParenPat> for Pat {
from(node: ParenPat) -> Pat3710     fn from(node: ParenPat) -> Pat { Pat::ParenPat(node) }
3711 }
3712 impl From<PathPat> for Pat {
from(node: PathPat) -> Pat3713     fn from(node: PathPat) -> Pat { Pat::PathPat(node) }
3714 }
3715 impl From<WildcardPat> for Pat {
from(node: WildcardPat) -> Pat3716     fn from(node: WildcardPat) -> Pat { Pat::WildcardPat(node) }
3717 }
3718 impl From<RangePat> for Pat {
from(node: RangePat) -> Pat3719     fn from(node: RangePat) -> Pat { Pat::RangePat(node) }
3720 }
3721 impl From<RecordPat> for Pat {
from(node: RecordPat) -> Pat3722     fn from(node: RecordPat) -> Pat { Pat::RecordPat(node) }
3723 }
3724 impl From<RefPat> for Pat {
from(node: RefPat) -> Pat3725     fn from(node: RefPat) -> Pat { Pat::RefPat(node) }
3726 }
3727 impl From<SlicePat> for Pat {
from(node: SlicePat) -> Pat3728     fn from(node: SlicePat) -> Pat { Pat::SlicePat(node) }
3729 }
3730 impl From<TuplePat> for Pat {
from(node: TuplePat) -> Pat3731     fn from(node: TuplePat) -> Pat { Pat::TuplePat(node) }
3732 }
3733 impl From<TupleStructPat> for Pat {
from(node: TupleStructPat) -> Pat3734     fn from(node: TupleStructPat) -> Pat { Pat::TupleStructPat(node) }
3735 }
3736 impl From<ConstBlockPat> for Pat {
from(node: ConstBlockPat) -> Pat3737     fn from(node: ConstBlockPat) -> Pat { Pat::ConstBlockPat(node) }
3738 }
3739 impl AstNode for Pat {
can_cast(kind: SyntaxKind) -> bool3740     fn can_cast(kind: SyntaxKind) -> bool {
3741         matches!(
3742             kind,
3743             IDENT_PAT
3744                 | BOX_PAT
3745                 | REST_PAT
3746                 | LITERAL_PAT
3747                 | MACRO_PAT
3748                 | OR_PAT
3749                 | PAREN_PAT
3750                 | PATH_PAT
3751                 | WILDCARD_PAT
3752                 | RANGE_PAT
3753                 | RECORD_PAT
3754                 | REF_PAT
3755                 | SLICE_PAT
3756                 | TUPLE_PAT
3757                 | TUPLE_STRUCT_PAT
3758                 | CONST_BLOCK_PAT
3759         )
3760     }
cast(syntax: SyntaxNode) -> Option<Self>3761     fn cast(syntax: SyntaxNode) -> Option<Self> {
3762         let res = match syntax.kind() {
3763             IDENT_PAT => Pat::IdentPat(IdentPat { syntax }),
3764             BOX_PAT => Pat::BoxPat(BoxPat { syntax }),
3765             REST_PAT => Pat::RestPat(RestPat { syntax }),
3766             LITERAL_PAT => Pat::LiteralPat(LiteralPat { syntax }),
3767             MACRO_PAT => Pat::MacroPat(MacroPat { syntax }),
3768             OR_PAT => Pat::OrPat(OrPat { syntax }),
3769             PAREN_PAT => Pat::ParenPat(ParenPat { syntax }),
3770             PATH_PAT => Pat::PathPat(PathPat { syntax }),
3771             WILDCARD_PAT => Pat::WildcardPat(WildcardPat { syntax }),
3772             RANGE_PAT => Pat::RangePat(RangePat { syntax }),
3773             RECORD_PAT => Pat::RecordPat(RecordPat { syntax }),
3774             REF_PAT => Pat::RefPat(RefPat { syntax }),
3775             SLICE_PAT => Pat::SlicePat(SlicePat { syntax }),
3776             TUPLE_PAT => Pat::TuplePat(TuplePat { syntax }),
3777             TUPLE_STRUCT_PAT => Pat::TupleStructPat(TupleStructPat { syntax }),
3778             CONST_BLOCK_PAT => Pat::ConstBlockPat(ConstBlockPat { syntax }),
3779             _ => return None,
3780         };
3781         Some(res)
3782     }
syntax(&self) -> &SyntaxNode3783     fn syntax(&self) -> &SyntaxNode {
3784         match self {
3785             Pat::IdentPat(it) => &it.syntax,
3786             Pat::BoxPat(it) => &it.syntax,
3787             Pat::RestPat(it) => &it.syntax,
3788             Pat::LiteralPat(it) => &it.syntax,
3789             Pat::MacroPat(it) => &it.syntax,
3790             Pat::OrPat(it) => &it.syntax,
3791             Pat::ParenPat(it) => &it.syntax,
3792             Pat::PathPat(it) => &it.syntax,
3793             Pat::WildcardPat(it) => &it.syntax,
3794             Pat::RangePat(it) => &it.syntax,
3795             Pat::RecordPat(it) => &it.syntax,
3796             Pat::RefPat(it) => &it.syntax,
3797             Pat::SlicePat(it) => &it.syntax,
3798             Pat::TuplePat(it) => &it.syntax,
3799             Pat::TupleStructPat(it) => &it.syntax,
3800             Pat::ConstBlockPat(it) => &it.syntax,
3801         }
3802     }
3803 }
3804 impl From<RecordFieldList> for FieldList {
from(node: RecordFieldList) -> FieldList3805     fn from(node: RecordFieldList) -> FieldList { FieldList::RecordFieldList(node) }
3806 }
3807 impl From<TupleFieldList> for FieldList {
from(node: TupleFieldList) -> FieldList3808     fn from(node: TupleFieldList) -> FieldList { FieldList::TupleFieldList(node) }
3809 }
3810 impl AstNode for FieldList {
can_cast(kind: SyntaxKind) -> bool3811     fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, RECORD_FIELD_LIST | TUPLE_FIELD_LIST) }
cast(syntax: SyntaxNode) -> Option<Self>3812     fn cast(syntax: SyntaxNode) -> Option<Self> {
3813         let res = match syntax.kind() {
3814             RECORD_FIELD_LIST => FieldList::RecordFieldList(RecordFieldList { syntax }),
3815             TUPLE_FIELD_LIST => FieldList::TupleFieldList(TupleFieldList { syntax }),
3816             _ => return None,
3817         };
3818         Some(res)
3819     }
syntax(&self) -> &SyntaxNode3820     fn syntax(&self) -> &SyntaxNode {
3821         match self {
3822             FieldList::RecordFieldList(it) => &it.syntax,
3823             FieldList::TupleFieldList(it) => &it.syntax,
3824         }
3825     }
3826 }
3827 impl From<Enum> for Adt {
from(node: Enum) -> Adt3828     fn from(node: Enum) -> Adt { Adt::Enum(node) }
3829 }
3830 impl From<Struct> for Adt {
from(node: Struct) -> Adt3831     fn from(node: Struct) -> Adt { Adt::Struct(node) }
3832 }
3833 impl From<Union> for Adt {
from(node: Union) -> Adt3834     fn from(node: Union) -> Adt { Adt::Union(node) }
3835 }
3836 impl AstNode for Adt {
can_cast(kind: SyntaxKind) -> bool3837     fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, ENUM | STRUCT | UNION) }
cast(syntax: SyntaxNode) -> Option<Self>3838     fn cast(syntax: SyntaxNode) -> Option<Self> {
3839         let res = match syntax.kind() {
3840             ENUM => Adt::Enum(Enum { syntax }),
3841             STRUCT => Adt::Struct(Struct { syntax }),
3842             UNION => Adt::Union(Union { syntax }),
3843             _ => return None,
3844         };
3845         Some(res)
3846     }
syntax(&self) -> &SyntaxNode3847     fn syntax(&self) -> &SyntaxNode {
3848         match self {
3849             Adt::Enum(it) => &it.syntax,
3850             Adt::Struct(it) => &it.syntax,
3851             Adt::Union(it) => &it.syntax,
3852         }
3853     }
3854 }
3855 impl From<Const> for AssocItem {
from(node: Const) -> AssocItem3856     fn from(node: Const) -> AssocItem { AssocItem::Const(node) }
3857 }
3858 impl From<Fn> for AssocItem {
from(node: Fn) -> AssocItem3859     fn from(node: Fn) -> AssocItem { AssocItem::Fn(node) }
3860 }
3861 impl From<MacroCall> for AssocItem {
from(node: MacroCall) -> AssocItem3862     fn from(node: MacroCall) -> AssocItem { AssocItem::MacroCall(node) }
3863 }
3864 impl From<TypeAlias> for AssocItem {
from(node: TypeAlias) -> AssocItem3865     fn from(node: TypeAlias) -> AssocItem { AssocItem::TypeAlias(node) }
3866 }
3867 impl AstNode for AssocItem {
can_cast(kind: SyntaxKind) -> bool3868     fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, CONST | FN | MACRO_CALL | TYPE_ALIAS) }
cast(syntax: SyntaxNode) -> Option<Self>3869     fn cast(syntax: SyntaxNode) -> Option<Self> {
3870         let res = match syntax.kind() {
3871             CONST => AssocItem::Const(Const { syntax }),
3872             FN => AssocItem::Fn(Fn { syntax }),
3873             MACRO_CALL => AssocItem::MacroCall(MacroCall { syntax }),
3874             TYPE_ALIAS => AssocItem::TypeAlias(TypeAlias { syntax }),
3875             _ => return None,
3876         };
3877         Some(res)
3878     }
syntax(&self) -> &SyntaxNode3879     fn syntax(&self) -> &SyntaxNode {
3880         match self {
3881             AssocItem::Const(it) => &it.syntax,
3882             AssocItem::Fn(it) => &it.syntax,
3883             AssocItem::MacroCall(it) => &it.syntax,
3884             AssocItem::TypeAlias(it) => &it.syntax,
3885         }
3886     }
3887 }
3888 impl From<Fn> for ExternItem {
from(node: Fn) -> ExternItem3889     fn from(node: Fn) -> ExternItem { ExternItem::Fn(node) }
3890 }
3891 impl From<MacroCall> for ExternItem {
from(node: MacroCall) -> ExternItem3892     fn from(node: MacroCall) -> ExternItem { ExternItem::MacroCall(node) }
3893 }
3894 impl From<Static> for ExternItem {
from(node: Static) -> ExternItem3895     fn from(node: Static) -> ExternItem { ExternItem::Static(node) }
3896 }
3897 impl From<TypeAlias> for ExternItem {
from(node: TypeAlias) -> ExternItem3898     fn from(node: TypeAlias) -> ExternItem { ExternItem::TypeAlias(node) }
3899 }
3900 impl AstNode for ExternItem {
can_cast(kind: SyntaxKind) -> bool3901     fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, FN | MACRO_CALL | STATIC | TYPE_ALIAS) }
cast(syntax: SyntaxNode) -> Option<Self>3902     fn cast(syntax: SyntaxNode) -> Option<Self> {
3903         let res = match syntax.kind() {
3904             FN => ExternItem::Fn(Fn { syntax }),
3905             MACRO_CALL => ExternItem::MacroCall(MacroCall { syntax }),
3906             STATIC => ExternItem::Static(Static { syntax }),
3907             TYPE_ALIAS => ExternItem::TypeAlias(TypeAlias { syntax }),
3908             _ => return None,
3909         };
3910         Some(res)
3911     }
syntax(&self) -> &SyntaxNode3912     fn syntax(&self) -> &SyntaxNode {
3913         match self {
3914             ExternItem::Fn(it) => &it.syntax,
3915             ExternItem::MacroCall(it) => &it.syntax,
3916             ExternItem::Static(it) => &it.syntax,
3917             ExternItem::TypeAlias(it) => &it.syntax,
3918         }
3919     }
3920 }
3921 impl From<ConstParam> for GenericParam {
from(node: ConstParam) -> GenericParam3922     fn from(node: ConstParam) -> GenericParam { GenericParam::ConstParam(node) }
3923 }
3924 impl From<LifetimeParam> for GenericParam {
from(node: LifetimeParam) -> GenericParam3925     fn from(node: LifetimeParam) -> GenericParam { GenericParam::LifetimeParam(node) }
3926 }
3927 impl From<TypeParam> for GenericParam {
from(node: TypeParam) -> GenericParam3928     fn from(node: TypeParam) -> GenericParam { GenericParam::TypeParam(node) }
3929 }
3930 impl AstNode for GenericParam {
can_cast(kind: SyntaxKind) -> bool3931     fn can_cast(kind: SyntaxKind) -> bool {
3932         matches!(kind, CONST_PARAM | LIFETIME_PARAM | TYPE_PARAM)
3933     }
cast(syntax: SyntaxNode) -> Option<Self>3934     fn cast(syntax: SyntaxNode) -> Option<Self> {
3935         let res = match syntax.kind() {
3936             CONST_PARAM => GenericParam::ConstParam(ConstParam { syntax }),
3937             LIFETIME_PARAM => GenericParam::LifetimeParam(LifetimeParam { syntax }),
3938             TYPE_PARAM => GenericParam::TypeParam(TypeParam { syntax }),
3939             _ => return None,
3940         };
3941         Some(res)
3942     }
syntax(&self) -> &SyntaxNode3943     fn syntax(&self) -> &SyntaxNode {
3944         match self {
3945             GenericParam::ConstParam(it) => &it.syntax,
3946             GenericParam::LifetimeParam(it) => &it.syntax,
3947             GenericParam::TypeParam(it) => &it.syntax,
3948         }
3949     }
3950 }
3951 impl AnyHasArgList {
3952     #[inline]
new<T: ast::HasArgList>(node: T) -> AnyHasArgList3953     pub fn new<T: ast::HasArgList>(node: T) -> AnyHasArgList {
3954         AnyHasArgList { syntax: node.syntax().clone() }
3955     }
3956 }
3957 impl AstNode for AnyHasArgList {
can_cast(kind: SyntaxKind) -> bool3958     fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, CALL_EXPR | METHOD_CALL_EXPR) }
cast(syntax: SyntaxNode) -> Option<Self>3959     fn cast(syntax: SyntaxNode) -> Option<Self> {
3960         Self::can_cast(syntax.kind()).then_some(AnyHasArgList { syntax })
3961     }
syntax(&self) -> &SyntaxNode3962     fn syntax(&self) -> &SyntaxNode { &self.syntax }
3963 }
3964 impl AnyHasAttrs {
3965     #[inline]
new<T: ast::HasAttrs>(node: T) -> AnyHasAttrs3966     pub fn new<T: ast::HasAttrs>(node: T) -> AnyHasAttrs {
3967         AnyHasAttrs { syntax: node.syntax().clone() }
3968     }
3969 }
3970 impl AstNode for AnyHasAttrs {
can_cast(kind: SyntaxKind) -> bool3971     fn can_cast(kind: SyntaxKind) -> bool {
3972         matches!(
3973             kind,
3974             MACRO_CALL
3975                 | SOURCE_FILE
3976                 | CONST
3977                 | ENUM
3978                 | EXTERN_BLOCK
3979                 | EXTERN_CRATE
3980                 | FN
3981                 | IMPL
3982                 | MACRO_RULES
3983                 | MACRO_DEF
3984                 | MODULE
3985                 | STATIC
3986                 | STRUCT
3987                 | TRAIT
3988                 | TRAIT_ALIAS
3989                 | TYPE_ALIAS
3990                 | UNION
3991                 | USE
3992                 | ITEM_LIST
3993                 | BLOCK_EXPR
3994                 | SELF_PARAM
3995                 | PARAM
3996                 | RECORD_FIELD
3997                 | TUPLE_FIELD
3998                 | VARIANT
3999                 | ASSOC_ITEM_LIST
4000                 | EXTERN_ITEM_LIST
4001                 | CONST_PARAM
4002                 | LIFETIME_PARAM
4003                 | TYPE_PARAM
4004                 | LET_STMT
4005                 | ARRAY_EXPR
4006                 | AWAIT_EXPR
4007                 | BIN_EXPR
4008                 | BOX_EXPR
4009                 | BREAK_EXPR
4010                 | CALL_EXPR
4011                 | CAST_EXPR
4012                 | CLOSURE_EXPR
4013                 | CONTINUE_EXPR
4014                 | FIELD_EXPR
4015                 | FOR_EXPR
4016                 | IF_EXPR
4017                 | INDEX_EXPR
4018                 | LITERAL
4019                 | LOOP_EXPR
4020                 | MATCH_EXPR
4021                 | METHOD_CALL_EXPR
4022                 | PAREN_EXPR
4023                 | PATH_EXPR
4024                 | PREFIX_EXPR
4025                 | RANGE_EXPR
4026                 | REF_EXPR
4027                 | RETURN_EXPR
4028                 | TRY_EXPR
4029                 | TUPLE_EXPR
4030                 | WHILE_EXPR
4031                 | YIELD_EXPR
4032                 | YEET_EXPR
4033                 | LET_EXPR
4034                 | UNDERSCORE_EXPR
4035                 | STMT_LIST
4036                 | RECORD_EXPR_FIELD_LIST
4037                 | RECORD_EXPR_FIELD
4038                 | MATCH_ARM_LIST
4039                 | MATCH_ARM
4040                 | IDENT_PAT
4041                 | REST_PAT
4042                 | RECORD_PAT_FIELD
4043         )
4044     }
cast(syntax: SyntaxNode) -> Option<Self>4045     fn cast(syntax: SyntaxNode) -> Option<Self> {
4046         Self::can_cast(syntax.kind()).then_some(AnyHasAttrs { syntax })
4047     }
syntax(&self) -> &SyntaxNode4048     fn syntax(&self) -> &SyntaxNode { &self.syntax }
4049 }
4050 impl AnyHasDocComments {
4051     #[inline]
new<T: ast::HasDocComments>(node: T) -> AnyHasDocComments4052     pub fn new<T: ast::HasDocComments>(node: T) -> AnyHasDocComments {
4053         AnyHasDocComments { syntax: node.syntax().clone() }
4054     }
4055 }
4056 impl AstNode for AnyHasDocComments {
can_cast(kind: SyntaxKind) -> bool4057     fn can_cast(kind: SyntaxKind) -> bool {
4058         matches!(
4059             kind,
4060             MACRO_CALL
4061                 | SOURCE_FILE
4062                 | CONST
4063                 | ENUM
4064                 | EXTERN_BLOCK
4065                 | EXTERN_CRATE
4066                 | FN
4067                 | IMPL
4068                 | MACRO_RULES
4069                 | MACRO_DEF
4070                 | MODULE
4071                 | STATIC
4072                 | STRUCT
4073                 | TRAIT
4074                 | TRAIT_ALIAS
4075                 | TYPE_ALIAS
4076                 | UNION
4077                 | USE
4078                 | RECORD_FIELD
4079                 | TUPLE_FIELD
4080                 | VARIANT
4081         )
4082     }
cast(syntax: SyntaxNode) -> Option<Self>4083     fn cast(syntax: SyntaxNode) -> Option<Self> {
4084         Self::can_cast(syntax.kind()).then_some(AnyHasDocComments { syntax })
4085     }
syntax(&self) -> &SyntaxNode4086     fn syntax(&self) -> &SyntaxNode { &self.syntax }
4087 }
4088 impl AnyHasGenericParams {
4089     #[inline]
new<T: ast::HasGenericParams>(node: T) -> AnyHasGenericParams4090     pub fn new<T: ast::HasGenericParams>(node: T) -> AnyHasGenericParams {
4091         AnyHasGenericParams { syntax: node.syntax().clone() }
4092     }
4093 }
4094 impl AstNode for AnyHasGenericParams {
can_cast(kind: SyntaxKind) -> bool4095     fn can_cast(kind: SyntaxKind) -> bool {
4096         matches!(kind, ENUM | FN | IMPL | STRUCT | TRAIT | TRAIT_ALIAS | TYPE_ALIAS | UNION)
4097     }
cast(syntax: SyntaxNode) -> Option<Self>4098     fn cast(syntax: SyntaxNode) -> Option<Self> {
4099         Self::can_cast(syntax.kind()).then_some(AnyHasGenericParams { syntax })
4100     }
syntax(&self) -> &SyntaxNode4101     fn syntax(&self) -> &SyntaxNode { &self.syntax }
4102 }
4103 impl AnyHasLoopBody {
4104     #[inline]
new<T: ast::HasLoopBody>(node: T) -> AnyHasLoopBody4105     pub fn new<T: ast::HasLoopBody>(node: T) -> AnyHasLoopBody {
4106         AnyHasLoopBody { syntax: node.syntax().clone() }
4107     }
4108 }
4109 impl AstNode for AnyHasLoopBody {
can_cast(kind: SyntaxKind) -> bool4110     fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, FOR_EXPR | LOOP_EXPR | WHILE_EXPR) }
cast(syntax: SyntaxNode) -> Option<Self>4111     fn cast(syntax: SyntaxNode) -> Option<Self> {
4112         Self::can_cast(syntax.kind()).then_some(AnyHasLoopBody { syntax })
4113     }
syntax(&self) -> &SyntaxNode4114     fn syntax(&self) -> &SyntaxNode { &self.syntax }
4115 }
4116 impl AnyHasModuleItem {
4117     #[inline]
new<T: ast::HasModuleItem>(node: T) -> AnyHasModuleItem4118     pub fn new<T: ast::HasModuleItem>(node: T) -> AnyHasModuleItem {
4119         AnyHasModuleItem { syntax: node.syntax().clone() }
4120     }
4121 }
4122 impl AstNode for AnyHasModuleItem {
can_cast(kind: SyntaxKind) -> bool4123     fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, MACRO_ITEMS | SOURCE_FILE | ITEM_LIST) }
cast(syntax: SyntaxNode) -> Option<Self>4124     fn cast(syntax: SyntaxNode) -> Option<Self> {
4125         Self::can_cast(syntax.kind()).then_some(AnyHasModuleItem { syntax })
4126     }
syntax(&self) -> &SyntaxNode4127     fn syntax(&self) -> &SyntaxNode { &self.syntax }
4128 }
4129 impl AnyHasName {
4130     #[inline]
new<T: ast::HasName>(node: T) -> AnyHasName4131     pub fn new<T: ast::HasName>(node: T) -> AnyHasName {
4132         AnyHasName { syntax: node.syntax().clone() }
4133     }
4134 }
4135 impl AstNode for AnyHasName {
can_cast(kind: SyntaxKind) -> bool4136     fn can_cast(kind: SyntaxKind) -> bool {
4137         matches!(
4138             kind,
4139             CONST
4140                 | ENUM
4141                 | FN
4142                 | MACRO_RULES
4143                 | MACRO_DEF
4144                 | MODULE
4145                 | STATIC
4146                 | STRUCT
4147                 | TRAIT
4148                 | TRAIT_ALIAS
4149                 | TYPE_ALIAS
4150                 | UNION
4151                 | RENAME
4152                 | SELF_PARAM
4153                 | RECORD_FIELD
4154                 | VARIANT
4155                 | CONST_PARAM
4156                 | TYPE_PARAM
4157                 | IDENT_PAT
4158         )
4159     }
cast(syntax: SyntaxNode) -> Option<Self>4160     fn cast(syntax: SyntaxNode) -> Option<Self> {
4161         Self::can_cast(syntax.kind()).then_some(AnyHasName { syntax })
4162     }
syntax(&self) -> &SyntaxNode4163     fn syntax(&self) -> &SyntaxNode { &self.syntax }
4164 }
4165 impl AnyHasTypeBounds {
4166     #[inline]
new<T: ast::HasTypeBounds>(node: T) -> AnyHasTypeBounds4167     pub fn new<T: ast::HasTypeBounds>(node: T) -> AnyHasTypeBounds {
4168         AnyHasTypeBounds { syntax: node.syntax().clone() }
4169     }
4170 }
4171 impl AstNode for AnyHasTypeBounds {
can_cast(kind: SyntaxKind) -> bool4172     fn can_cast(kind: SyntaxKind) -> bool {
4173         matches!(
4174             kind,
4175             ASSOC_TYPE_ARG | TRAIT | TYPE_ALIAS | LIFETIME_PARAM | TYPE_PARAM | WHERE_PRED
4176         )
4177     }
cast(syntax: SyntaxNode) -> Option<Self>4178     fn cast(syntax: SyntaxNode) -> Option<Self> {
4179         Self::can_cast(syntax.kind()).then_some(AnyHasTypeBounds { syntax })
4180     }
syntax(&self) -> &SyntaxNode4181     fn syntax(&self) -> &SyntaxNode { &self.syntax }
4182 }
4183 impl AnyHasVisibility {
4184     #[inline]
new<T: ast::HasVisibility>(node: T) -> AnyHasVisibility4185     pub fn new<T: ast::HasVisibility>(node: T) -> AnyHasVisibility {
4186         AnyHasVisibility { syntax: node.syntax().clone() }
4187     }
4188 }
4189 impl AstNode for AnyHasVisibility {
can_cast(kind: SyntaxKind) -> bool4190     fn can_cast(kind: SyntaxKind) -> bool {
4191         matches!(
4192             kind,
4193             CONST
4194                 | ENUM
4195                 | EXTERN_CRATE
4196                 | FN
4197                 | IMPL
4198                 | MACRO_RULES
4199                 | MACRO_DEF
4200                 | MODULE
4201                 | STATIC
4202                 | STRUCT
4203                 | TRAIT
4204                 | TRAIT_ALIAS
4205                 | TYPE_ALIAS
4206                 | UNION
4207                 | USE
4208                 | RECORD_FIELD
4209                 | TUPLE_FIELD
4210                 | VARIANT
4211         )
4212     }
cast(syntax: SyntaxNode) -> Option<Self>4213     fn cast(syntax: SyntaxNode) -> Option<Self> {
4214         Self::can_cast(syntax.kind()).then_some(AnyHasVisibility { syntax })
4215     }
syntax(&self) -> &SyntaxNode4216     fn syntax(&self) -> &SyntaxNode { &self.syntax }
4217 }
4218 impl std::fmt::Display for GenericArg {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4219     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4220         std::fmt::Display::fmt(self.syntax(), f)
4221     }
4222 }
4223 impl std::fmt::Display for Type {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4224     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4225         std::fmt::Display::fmt(self.syntax(), f)
4226     }
4227 }
4228 impl std::fmt::Display for Expr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4229     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4230         std::fmt::Display::fmt(self.syntax(), f)
4231     }
4232 }
4233 impl std::fmt::Display for Item {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4234     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4235         std::fmt::Display::fmt(self.syntax(), f)
4236     }
4237 }
4238 impl std::fmt::Display for Stmt {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4239     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4240         std::fmt::Display::fmt(self.syntax(), f)
4241     }
4242 }
4243 impl std::fmt::Display for Pat {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4244     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4245         std::fmt::Display::fmt(self.syntax(), f)
4246     }
4247 }
4248 impl std::fmt::Display for FieldList {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4249     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4250         std::fmt::Display::fmt(self.syntax(), f)
4251     }
4252 }
4253 impl std::fmt::Display for Adt {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4254     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4255         std::fmt::Display::fmt(self.syntax(), f)
4256     }
4257 }
4258 impl std::fmt::Display for AssocItem {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4259     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4260         std::fmt::Display::fmt(self.syntax(), f)
4261     }
4262 }
4263 impl std::fmt::Display for ExternItem {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4264     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4265         std::fmt::Display::fmt(self.syntax(), f)
4266     }
4267 }
4268 impl std::fmt::Display for GenericParam {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4269     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4270         std::fmt::Display::fmt(self.syntax(), f)
4271     }
4272 }
4273 impl std::fmt::Display for Name {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4274     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4275         std::fmt::Display::fmt(self.syntax(), f)
4276     }
4277 }
4278 impl std::fmt::Display for NameRef {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4279     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4280         std::fmt::Display::fmt(self.syntax(), f)
4281     }
4282 }
4283 impl std::fmt::Display for Lifetime {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4284     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4285         std::fmt::Display::fmt(self.syntax(), f)
4286     }
4287 }
4288 impl std::fmt::Display for Path {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4289     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4290         std::fmt::Display::fmt(self.syntax(), f)
4291     }
4292 }
4293 impl std::fmt::Display for PathSegment {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4294     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4295         std::fmt::Display::fmt(self.syntax(), f)
4296     }
4297 }
4298 impl std::fmt::Display for GenericArgList {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4299     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4300         std::fmt::Display::fmt(self.syntax(), f)
4301     }
4302 }
4303 impl std::fmt::Display for ParamList {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4304     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4305         std::fmt::Display::fmt(self.syntax(), f)
4306     }
4307 }
4308 impl std::fmt::Display for RetType {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4309     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4310         std::fmt::Display::fmt(self.syntax(), f)
4311     }
4312 }
4313 impl std::fmt::Display for PathType {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4314     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4315         std::fmt::Display::fmt(self.syntax(), f)
4316     }
4317 }
4318 impl std::fmt::Display for TypeArg {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4319     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4320         std::fmt::Display::fmt(self.syntax(), f)
4321     }
4322 }
4323 impl std::fmt::Display for AssocTypeArg {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4324     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4325         std::fmt::Display::fmt(self.syntax(), f)
4326     }
4327 }
4328 impl std::fmt::Display for LifetimeArg {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4329     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4330         std::fmt::Display::fmt(self.syntax(), f)
4331     }
4332 }
4333 impl std::fmt::Display for ConstArg {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4334     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4335         std::fmt::Display::fmt(self.syntax(), f)
4336     }
4337 }
4338 impl std::fmt::Display for TypeBoundList {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4339     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4340         std::fmt::Display::fmt(self.syntax(), f)
4341     }
4342 }
4343 impl std::fmt::Display for MacroCall {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4344     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4345         std::fmt::Display::fmt(self.syntax(), f)
4346     }
4347 }
4348 impl std::fmt::Display for Attr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4349     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4350         std::fmt::Display::fmt(self.syntax(), f)
4351     }
4352 }
4353 impl std::fmt::Display for TokenTree {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4354     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4355         std::fmt::Display::fmt(self.syntax(), f)
4356     }
4357 }
4358 impl std::fmt::Display for MacroItems {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4359     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4360         std::fmt::Display::fmt(self.syntax(), f)
4361     }
4362 }
4363 impl std::fmt::Display for MacroStmts {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4364     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4365         std::fmt::Display::fmt(self.syntax(), f)
4366     }
4367 }
4368 impl std::fmt::Display for SourceFile {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4369     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4370         std::fmt::Display::fmt(self.syntax(), f)
4371     }
4372 }
4373 impl std::fmt::Display for Const {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4374     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4375         std::fmt::Display::fmt(self.syntax(), f)
4376     }
4377 }
4378 impl std::fmt::Display for Enum {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4379     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4380         std::fmt::Display::fmt(self.syntax(), f)
4381     }
4382 }
4383 impl std::fmt::Display for ExternBlock {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4384     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4385         std::fmt::Display::fmt(self.syntax(), f)
4386     }
4387 }
4388 impl std::fmt::Display for ExternCrate {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4389     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4390         std::fmt::Display::fmt(self.syntax(), f)
4391     }
4392 }
4393 impl std::fmt::Display for Fn {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4394     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4395         std::fmt::Display::fmt(self.syntax(), f)
4396     }
4397 }
4398 impl std::fmt::Display for Impl {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4399     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4400         std::fmt::Display::fmt(self.syntax(), f)
4401     }
4402 }
4403 impl std::fmt::Display for MacroRules {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4404     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4405         std::fmt::Display::fmt(self.syntax(), f)
4406     }
4407 }
4408 impl std::fmt::Display for MacroDef {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4409     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4410         std::fmt::Display::fmt(self.syntax(), f)
4411     }
4412 }
4413 impl std::fmt::Display for Module {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4414     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4415         std::fmt::Display::fmt(self.syntax(), f)
4416     }
4417 }
4418 impl std::fmt::Display for Static {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4419     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4420         std::fmt::Display::fmt(self.syntax(), f)
4421     }
4422 }
4423 impl std::fmt::Display for Struct {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4424     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4425         std::fmt::Display::fmt(self.syntax(), f)
4426     }
4427 }
4428 impl std::fmt::Display for Trait {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4429     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4430         std::fmt::Display::fmt(self.syntax(), f)
4431     }
4432 }
4433 impl std::fmt::Display for TraitAlias {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4434     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4435         std::fmt::Display::fmt(self.syntax(), f)
4436     }
4437 }
4438 impl std::fmt::Display for TypeAlias {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4439     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4440         std::fmt::Display::fmt(self.syntax(), f)
4441     }
4442 }
4443 impl std::fmt::Display for Union {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4444     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4445         std::fmt::Display::fmt(self.syntax(), f)
4446     }
4447 }
4448 impl std::fmt::Display for Use {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4449     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4450         std::fmt::Display::fmt(self.syntax(), f)
4451     }
4452 }
4453 impl std::fmt::Display for Visibility {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4454     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4455         std::fmt::Display::fmt(self.syntax(), f)
4456     }
4457 }
4458 impl std::fmt::Display for ItemList {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4459     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4460         std::fmt::Display::fmt(self.syntax(), f)
4461     }
4462 }
4463 impl std::fmt::Display for Rename {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4464     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4465         std::fmt::Display::fmt(self.syntax(), f)
4466     }
4467 }
4468 impl std::fmt::Display for UseTree {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4469     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4470         std::fmt::Display::fmt(self.syntax(), f)
4471     }
4472 }
4473 impl std::fmt::Display for UseTreeList {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4474     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4475         std::fmt::Display::fmt(self.syntax(), f)
4476     }
4477 }
4478 impl std::fmt::Display for Abi {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4479     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4480         std::fmt::Display::fmt(self.syntax(), f)
4481     }
4482 }
4483 impl std::fmt::Display for GenericParamList {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4484     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4485         std::fmt::Display::fmt(self.syntax(), f)
4486     }
4487 }
4488 impl std::fmt::Display for WhereClause {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4489     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4490         std::fmt::Display::fmt(self.syntax(), f)
4491     }
4492 }
4493 impl std::fmt::Display for BlockExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4494     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4495         std::fmt::Display::fmt(self.syntax(), f)
4496     }
4497 }
4498 impl std::fmt::Display for SelfParam {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4499     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4500         std::fmt::Display::fmt(self.syntax(), f)
4501     }
4502 }
4503 impl std::fmt::Display for Param {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4504     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4505         std::fmt::Display::fmt(self.syntax(), f)
4506     }
4507 }
4508 impl std::fmt::Display for RecordFieldList {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4509     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4510         std::fmt::Display::fmt(self.syntax(), f)
4511     }
4512 }
4513 impl std::fmt::Display for TupleFieldList {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4514     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4515         std::fmt::Display::fmt(self.syntax(), f)
4516     }
4517 }
4518 impl std::fmt::Display for RecordField {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4519     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4520         std::fmt::Display::fmt(self.syntax(), f)
4521     }
4522 }
4523 impl std::fmt::Display for TupleField {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4524     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4525         std::fmt::Display::fmt(self.syntax(), f)
4526     }
4527 }
4528 impl std::fmt::Display for VariantList {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4529     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4530         std::fmt::Display::fmt(self.syntax(), f)
4531     }
4532 }
4533 impl std::fmt::Display for Variant {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4534     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4535         std::fmt::Display::fmt(self.syntax(), f)
4536     }
4537 }
4538 impl std::fmt::Display for AssocItemList {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4539     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4540         std::fmt::Display::fmt(self.syntax(), f)
4541     }
4542 }
4543 impl std::fmt::Display for ExternItemList {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4544     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4545         std::fmt::Display::fmt(self.syntax(), f)
4546     }
4547 }
4548 impl std::fmt::Display for ConstParam {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4549     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4550         std::fmt::Display::fmt(self.syntax(), f)
4551     }
4552 }
4553 impl std::fmt::Display for LifetimeParam {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4554     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4555         std::fmt::Display::fmt(self.syntax(), f)
4556     }
4557 }
4558 impl std::fmt::Display for TypeParam {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4559     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4560         std::fmt::Display::fmt(self.syntax(), f)
4561     }
4562 }
4563 impl std::fmt::Display for WherePred {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4564     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4565         std::fmt::Display::fmt(self.syntax(), f)
4566     }
4567 }
4568 impl std::fmt::Display for Meta {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4569     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4570         std::fmt::Display::fmt(self.syntax(), f)
4571     }
4572 }
4573 impl std::fmt::Display for ExprStmt {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4574     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4575         std::fmt::Display::fmt(self.syntax(), f)
4576     }
4577 }
4578 impl std::fmt::Display for LetStmt {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4579     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4580         std::fmt::Display::fmt(self.syntax(), f)
4581     }
4582 }
4583 impl std::fmt::Display for LetElse {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4584     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4585         std::fmt::Display::fmt(self.syntax(), f)
4586     }
4587 }
4588 impl std::fmt::Display for ArrayExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4589     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4590         std::fmt::Display::fmt(self.syntax(), f)
4591     }
4592 }
4593 impl std::fmt::Display for AwaitExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4594     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4595         std::fmt::Display::fmt(self.syntax(), f)
4596     }
4597 }
4598 impl std::fmt::Display for BinExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4599     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4600         std::fmt::Display::fmt(self.syntax(), f)
4601     }
4602 }
4603 impl std::fmt::Display for BoxExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4604     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4605         std::fmt::Display::fmt(self.syntax(), f)
4606     }
4607 }
4608 impl std::fmt::Display for BreakExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4609     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4610         std::fmt::Display::fmt(self.syntax(), f)
4611     }
4612 }
4613 impl std::fmt::Display for CallExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4614     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4615         std::fmt::Display::fmt(self.syntax(), f)
4616     }
4617 }
4618 impl std::fmt::Display for CastExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4619     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4620         std::fmt::Display::fmt(self.syntax(), f)
4621     }
4622 }
4623 impl std::fmt::Display for ClosureExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4624     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4625         std::fmt::Display::fmt(self.syntax(), f)
4626     }
4627 }
4628 impl std::fmt::Display for ContinueExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4629     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4630         std::fmt::Display::fmt(self.syntax(), f)
4631     }
4632 }
4633 impl std::fmt::Display for FieldExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4634     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4635         std::fmt::Display::fmt(self.syntax(), f)
4636     }
4637 }
4638 impl std::fmt::Display for ForExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4639     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4640         std::fmt::Display::fmt(self.syntax(), f)
4641     }
4642 }
4643 impl std::fmt::Display for IfExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4644     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4645         std::fmt::Display::fmt(self.syntax(), f)
4646     }
4647 }
4648 impl std::fmt::Display for IndexExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4649     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4650         std::fmt::Display::fmt(self.syntax(), f)
4651     }
4652 }
4653 impl std::fmt::Display for Literal {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4654     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4655         std::fmt::Display::fmt(self.syntax(), f)
4656     }
4657 }
4658 impl std::fmt::Display for LoopExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4659     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4660         std::fmt::Display::fmt(self.syntax(), f)
4661     }
4662 }
4663 impl std::fmt::Display for MacroExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4664     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4665         std::fmt::Display::fmt(self.syntax(), f)
4666     }
4667 }
4668 impl std::fmt::Display for MatchExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4669     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4670         std::fmt::Display::fmt(self.syntax(), f)
4671     }
4672 }
4673 impl std::fmt::Display for MethodCallExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4674     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4675         std::fmt::Display::fmt(self.syntax(), f)
4676     }
4677 }
4678 impl std::fmt::Display for ParenExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4679     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4680         std::fmt::Display::fmt(self.syntax(), f)
4681     }
4682 }
4683 impl std::fmt::Display for PathExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4684     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4685         std::fmt::Display::fmt(self.syntax(), f)
4686     }
4687 }
4688 impl std::fmt::Display for PrefixExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4689     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4690         std::fmt::Display::fmt(self.syntax(), f)
4691     }
4692 }
4693 impl std::fmt::Display for RangeExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4694     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4695         std::fmt::Display::fmt(self.syntax(), f)
4696     }
4697 }
4698 impl std::fmt::Display for RecordExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4699     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4700         std::fmt::Display::fmt(self.syntax(), f)
4701     }
4702 }
4703 impl std::fmt::Display for RefExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4704     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4705         std::fmt::Display::fmt(self.syntax(), f)
4706     }
4707 }
4708 impl std::fmt::Display for ReturnExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4709     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4710         std::fmt::Display::fmt(self.syntax(), f)
4711     }
4712 }
4713 impl std::fmt::Display for TryExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4714     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4715         std::fmt::Display::fmt(self.syntax(), f)
4716     }
4717 }
4718 impl std::fmt::Display for TupleExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4719     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4720         std::fmt::Display::fmt(self.syntax(), f)
4721     }
4722 }
4723 impl std::fmt::Display for WhileExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4724     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4725         std::fmt::Display::fmt(self.syntax(), f)
4726     }
4727 }
4728 impl std::fmt::Display for YieldExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4729     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4730         std::fmt::Display::fmt(self.syntax(), f)
4731     }
4732 }
4733 impl std::fmt::Display for YeetExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4734     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4735         std::fmt::Display::fmt(self.syntax(), f)
4736     }
4737 }
4738 impl std::fmt::Display for LetExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4739     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4740         std::fmt::Display::fmt(self.syntax(), f)
4741     }
4742 }
4743 impl std::fmt::Display for UnderscoreExpr {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4744     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4745         std::fmt::Display::fmt(self.syntax(), f)
4746     }
4747 }
4748 impl std::fmt::Display for StmtList {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4749     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4750         std::fmt::Display::fmt(self.syntax(), f)
4751     }
4752 }
4753 impl std::fmt::Display for Label {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4754     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4755         std::fmt::Display::fmt(self.syntax(), f)
4756     }
4757 }
4758 impl std::fmt::Display for RecordExprFieldList {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4759     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4760         std::fmt::Display::fmt(self.syntax(), f)
4761     }
4762 }
4763 impl std::fmt::Display for RecordExprField {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4764     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4765         std::fmt::Display::fmt(self.syntax(), f)
4766     }
4767 }
4768 impl std::fmt::Display for ArgList {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4769     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4770         std::fmt::Display::fmt(self.syntax(), f)
4771     }
4772 }
4773 impl std::fmt::Display for MatchArmList {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4774     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4775         std::fmt::Display::fmt(self.syntax(), f)
4776     }
4777 }
4778 impl std::fmt::Display for MatchArm {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4779     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4780         std::fmt::Display::fmt(self.syntax(), f)
4781     }
4782 }
4783 impl std::fmt::Display for MatchGuard {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4784     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4785         std::fmt::Display::fmt(self.syntax(), f)
4786     }
4787 }
4788 impl std::fmt::Display for ArrayType {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4789     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4790         std::fmt::Display::fmt(self.syntax(), f)
4791     }
4792 }
4793 impl std::fmt::Display for DynTraitType {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4794     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4795         std::fmt::Display::fmt(self.syntax(), f)
4796     }
4797 }
4798 impl std::fmt::Display for FnPtrType {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4799     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4800         std::fmt::Display::fmt(self.syntax(), f)
4801     }
4802 }
4803 impl std::fmt::Display for ForType {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4804     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4805         std::fmt::Display::fmt(self.syntax(), f)
4806     }
4807 }
4808 impl std::fmt::Display for ImplTraitType {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4809     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4810         std::fmt::Display::fmt(self.syntax(), f)
4811     }
4812 }
4813 impl std::fmt::Display for InferType {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4814     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4815         std::fmt::Display::fmt(self.syntax(), f)
4816     }
4817 }
4818 impl std::fmt::Display for MacroType {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4819     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4820         std::fmt::Display::fmt(self.syntax(), f)
4821     }
4822 }
4823 impl std::fmt::Display for NeverType {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4824     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4825         std::fmt::Display::fmt(self.syntax(), f)
4826     }
4827 }
4828 impl std::fmt::Display for ParenType {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4829     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4830         std::fmt::Display::fmt(self.syntax(), f)
4831     }
4832 }
4833 impl std::fmt::Display for PtrType {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4834     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4835         std::fmt::Display::fmt(self.syntax(), f)
4836     }
4837 }
4838 impl std::fmt::Display for RefType {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4839     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4840         std::fmt::Display::fmt(self.syntax(), f)
4841     }
4842 }
4843 impl std::fmt::Display for SliceType {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4844     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4845         std::fmt::Display::fmt(self.syntax(), f)
4846     }
4847 }
4848 impl std::fmt::Display for TupleType {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4849     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4850         std::fmt::Display::fmt(self.syntax(), f)
4851     }
4852 }
4853 impl std::fmt::Display for TypeBound {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4854     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4855         std::fmt::Display::fmt(self.syntax(), f)
4856     }
4857 }
4858 impl std::fmt::Display for IdentPat {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4859     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4860         std::fmt::Display::fmt(self.syntax(), f)
4861     }
4862 }
4863 impl std::fmt::Display for BoxPat {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4864     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4865         std::fmt::Display::fmt(self.syntax(), f)
4866     }
4867 }
4868 impl std::fmt::Display for RestPat {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4869     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4870         std::fmt::Display::fmt(self.syntax(), f)
4871     }
4872 }
4873 impl std::fmt::Display for LiteralPat {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4874     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4875         std::fmt::Display::fmt(self.syntax(), f)
4876     }
4877 }
4878 impl std::fmt::Display for MacroPat {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4879     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4880         std::fmt::Display::fmt(self.syntax(), f)
4881     }
4882 }
4883 impl std::fmt::Display for OrPat {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4884     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4885         std::fmt::Display::fmt(self.syntax(), f)
4886     }
4887 }
4888 impl std::fmt::Display for ParenPat {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4889     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4890         std::fmt::Display::fmt(self.syntax(), f)
4891     }
4892 }
4893 impl std::fmt::Display for PathPat {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4894     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4895         std::fmt::Display::fmt(self.syntax(), f)
4896     }
4897 }
4898 impl std::fmt::Display for WildcardPat {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4899     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4900         std::fmt::Display::fmt(self.syntax(), f)
4901     }
4902 }
4903 impl std::fmt::Display for RangePat {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4904     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4905         std::fmt::Display::fmt(self.syntax(), f)
4906     }
4907 }
4908 impl std::fmt::Display for RecordPat {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4909     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4910         std::fmt::Display::fmt(self.syntax(), f)
4911     }
4912 }
4913 impl std::fmt::Display for RefPat {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4914     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4915         std::fmt::Display::fmt(self.syntax(), f)
4916     }
4917 }
4918 impl std::fmt::Display for SlicePat {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4919     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4920         std::fmt::Display::fmt(self.syntax(), f)
4921     }
4922 }
4923 impl std::fmt::Display for TuplePat {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4924     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4925         std::fmt::Display::fmt(self.syntax(), f)
4926     }
4927 }
4928 impl std::fmt::Display for TupleStructPat {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4929     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4930         std::fmt::Display::fmt(self.syntax(), f)
4931     }
4932 }
4933 impl std::fmt::Display for ConstBlockPat {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4934     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4935         std::fmt::Display::fmt(self.syntax(), f)
4936     }
4937 }
4938 impl std::fmt::Display for RecordPatFieldList {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4939     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4940         std::fmt::Display::fmt(self.syntax(), f)
4941     }
4942 }
4943 impl std::fmt::Display for RecordPatField {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result4944     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4945         std::fmt::Display::fmt(self.syntax(), f)
4946     }
4947 }
4948