1 //! Generated file, do not edit by hand, see `xtask/src/codegen`
4 ast::{self, support, AstChildren, AstNode},
6 SyntaxNode, SyntaxToken, T,
8 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
10 pub(crate) syntax: SyntaxNode,
13 pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
15 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
17 pub(crate) syntax: SyntaxNode,
20 pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
22 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
24 pub(crate) syntax: SyntaxNode,
27 pub fn qualifier(&self) -> Option<Path> { support::child(&self.syntax) }
28 pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
29 pub fn segment(&self) -> Option<PathSegment> { support::child(&self.syntax) }
31 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
32 pub struct PathSegment {
33 pub(crate) syntax: SyntaxNode,
36 pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
37 pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
38 pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }
39 pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
40 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
41 pub fn generic_arg_list(&self) -> Option<GenericArgList> { support::child(&self.syntax) }
42 pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
43 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
44 pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
45 pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) }
46 pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
47 pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
49 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
50 pub struct GenericArgList {
51 pub(crate) syntax: SyntaxNode,
54 pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
55 pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
56 pub fn generic_args(&self) -> AstChildren<GenericArg> { support::children(&self.syntax) }
57 pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
59 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
60 pub struct ParamList {
61 pub(crate) syntax: SyntaxNode,
64 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
65 pub fn self_param(&self) -> Option<SelfParam> { support::child(&self.syntax) }
66 pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
67 pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) }
68 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
70 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
72 pub(crate) syntax: SyntaxNode,
75 pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) }
76 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
78 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
80 pub(crate) syntax: SyntaxNode,
83 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
85 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
87 pub(crate) syntax: SyntaxNode,
90 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
92 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
93 pub struct AssocTypeArg {
94 pub(crate) syntax: SyntaxNode,
96 impl ast::TypeBoundsOwner for AssocTypeArg {}
98 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
99 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
100 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
102 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
103 pub struct LifetimeArg {
104 pub(crate) syntax: SyntaxNode,
107 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
108 support::token(&self.syntax, T![lifetime])
111 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
112 pub struct ConstArg {
113 pub(crate) syntax: SyntaxNode,
116 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
118 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
119 pub struct TypeBoundList {
120 pub(crate) syntax: SyntaxNode,
123 pub fn bounds(&self) -> AstChildren<TypeBound> { support::children(&self.syntax) }
125 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
126 pub struct MacroCall {
127 pub(crate) syntax: SyntaxNode,
129 impl ast::AttrsOwner for MacroCall {}
130 impl ast::NameOwner for MacroCall {}
132 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
133 pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
134 pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
135 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
137 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
139 pub(crate) syntax: SyntaxNode,
142 pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
143 pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
144 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
145 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
146 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
147 pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
148 pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
149 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
151 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
152 pub struct TokenTree {
153 pub(crate) syntax: SyntaxNode,
156 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
157 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
158 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
159 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
160 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
161 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
163 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
164 pub struct MacroItems {
165 pub(crate) syntax: SyntaxNode,
167 impl ast::ModuleItemOwner for MacroItems {}
169 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
170 pub struct MacroStmts {
171 pub(crate) syntax: SyntaxNode,
174 pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
175 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
177 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
178 pub struct SourceFile {
179 pub(crate) syntax: SyntaxNode,
181 impl ast::AttrsOwner for SourceFile {}
182 impl ast::ModuleItemOwner for SourceFile {}
184 pub fn shebang_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![shebang]) }
186 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
188 pub(crate) syntax: SyntaxNode,
190 impl ast::AttrsOwner for Const {}
191 impl ast::NameOwner for Const {}
192 impl ast::VisibilityOwner for Const {}
194 pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
195 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
196 pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
197 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
198 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
199 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
200 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
201 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
203 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
205 pub(crate) syntax: SyntaxNode,
207 impl ast::AttrsOwner for Enum {}
208 impl ast::NameOwner for Enum {}
209 impl ast::VisibilityOwner for Enum {}
210 impl ast::GenericParamsOwner for Enum {}
212 pub fn enum_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![enum]) }
213 pub fn variant_list(&self) -> Option<VariantList> { support::child(&self.syntax) }
215 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
216 pub struct ExternBlock {
217 pub(crate) syntax: SyntaxNode,
219 impl ast::AttrsOwner for ExternBlock {}
221 pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
222 pub fn extern_item_list(&self) -> Option<ExternItemList> { support::child(&self.syntax) }
224 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
225 pub struct ExternCrate {
226 pub(crate) syntax: SyntaxNode,
228 impl ast::AttrsOwner for ExternCrate {}
229 impl ast::VisibilityOwner for ExternCrate {}
231 pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }
232 pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
233 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
234 pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
235 pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) }
236 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
238 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
240 pub(crate) syntax: SyntaxNode,
242 impl ast::AttrsOwner for Fn {}
243 impl ast::NameOwner for Fn {}
244 impl ast::VisibilityOwner for Fn {}
245 impl ast::GenericParamsOwner for Fn {}
247 pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
248 pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
249 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
250 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
251 pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
252 pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) }
253 pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
254 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
255 pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
256 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
258 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
260 pub(crate) syntax: SyntaxNode,
262 impl ast::AttrsOwner for Impl {}
263 impl ast::VisibilityOwner for Impl {}
264 impl ast::GenericParamsOwner for Impl {}
266 pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
267 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
268 pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
269 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
270 pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
271 pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
272 pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }
274 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
276 pub(crate) syntax: SyntaxNode,
278 impl ast::AttrsOwner for Module {}
279 impl ast::NameOwner for Module {}
280 impl ast::VisibilityOwner for Module {}
282 pub fn mod_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mod]) }
283 pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
284 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
286 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
288 pub(crate) syntax: SyntaxNode,
290 impl ast::AttrsOwner for Static {}
291 impl ast::NameOwner for Static {}
292 impl ast::VisibilityOwner for Static {}
294 pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) }
295 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
296 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
297 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
298 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
299 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
300 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
302 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
304 pub(crate) syntax: SyntaxNode,
306 impl ast::AttrsOwner for Struct {}
307 impl ast::NameOwner for Struct {}
308 impl ast::VisibilityOwner for Struct {}
309 impl ast::GenericParamsOwner for Struct {}
311 pub fn struct_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![struct]) }
312 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
313 pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) }
315 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
317 pub(crate) syntax: SyntaxNode,
319 impl ast::AttrsOwner for Trait {}
320 impl ast::NameOwner for Trait {}
321 impl ast::VisibilityOwner for Trait {}
322 impl ast::GenericParamsOwner for Trait {}
323 impl ast::TypeBoundsOwner for Trait {}
325 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
326 pub fn auto_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![auto]) }
327 pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) }
328 pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }
330 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
331 pub struct TypeAlias {
332 pub(crate) syntax: SyntaxNode,
334 impl ast::AttrsOwner for TypeAlias {}
335 impl ast::NameOwner for TypeAlias {}
336 impl ast::VisibilityOwner for TypeAlias {}
337 impl ast::GenericParamsOwner for TypeAlias {}
338 impl ast::TypeBoundsOwner for TypeAlias {}
340 pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
341 pub fn type_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![type]) }
342 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
343 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
344 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
346 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
348 pub(crate) syntax: SyntaxNode,
350 impl ast::AttrsOwner for Union {}
351 impl ast::NameOwner for Union {}
352 impl ast::VisibilityOwner for Union {}
353 impl ast::GenericParamsOwner for Union {}
355 pub fn union_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![union]) }
356 pub fn record_field_list(&self) -> Option<RecordFieldList> { support::child(&self.syntax) }
358 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
360 pub(crate) syntax: SyntaxNode,
362 impl ast::AttrsOwner for Use {}
363 impl ast::VisibilityOwner for Use {}
365 pub fn use_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![use]) }
366 pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) }
367 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
369 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
370 pub struct Visibility {
371 pub(crate) syntax: SyntaxNode,
374 pub fn pub_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![pub]) }
375 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
376 pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }
377 pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
378 pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
379 pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
380 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
381 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
383 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
384 pub struct ItemList {
385 pub(crate) syntax: SyntaxNode,
387 impl ast::AttrsOwner for ItemList {}
388 impl ast::ModuleItemOwner for ItemList {}
390 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
391 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
393 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
395 pub(crate) syntax: SyntaxNode,
397 impl ast::NameOwner for Rename {}
399 pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
400 pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
402 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
404 pub(crate) syntax: SyntaxNode,
407 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
408 pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
409 pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
410 pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) }
411 pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) }
413 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
414 pub struct UseTreeList {
415 pub(crate) syntax: SyntaxNode,
418 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
419 pub fn use_trees(&self) -> AstChildren<UseTree> { support::children(&self.syntax) }
420 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
422 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
424 pub(crate) syntax: SyntaxNode,
427 pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }
429 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
430 pub struct GenericParamList {
431 pub(crate) syntax: SyntaxNode,
433 impl GenericParamList {
434 pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
435 pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) }
436 pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
438 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
439 pub struct WhereClause {
440 pub(crate) syntax: SyntaxNode,
443 pub fn where_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![where]) }
444 pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) }
446 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
447 pub struct BlockExpr {
448 pub(crate) syntax: SyntaxNode,
450 impl ast::AttrsOwner for BlockExpr {}
452 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
453 pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
454 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
455 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
457 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
458 pub struct SelfParam {
459 pub(crate) syntax: SyntaxNode,
461 impl ast::AttrsOwner for SelfParam {}
463 pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
464 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
465 support::token(&self.syntax, T![lifetime])
467 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
468 pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
469 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
470 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
472 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
474 pub(crate) syntax: SyntaxNode,
476 impl ast::AttrsOwner for Param {}
478 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
479 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
480 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
481 pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) }
483 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
484 pub struct RecordFieldList {
485 pub(crate) syntax: SyntaxNode,
487 impl RecordFieldList {
488 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
489 pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) }
490 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
492 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
493 pub struct TupleFieldList {
494 pub(crate) syntax: SyntaxNode,
496 impl TupleFieldList {
497 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
498 pub fn fields(&self) -> AstChildren<TupleField> { support::children(&self.syntax) }
499 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
501 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
502 pub struct RecordField {
503 pub(crate) syntax: SyntaxNode,
505 impl ast::AttrsOwner for RecordField {}
506 impl ast::NameOwner for RecordField {}
507 impl ast::VisibilityOwner for RecordField {}
509 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
510 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
512 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
513 pub struct TupleField {
514 pub(crate) syntax: SyntaxNode,
516 impl ast::AttrsOwner for TupleField {}
517 impl ast::VisibilityOwner for TupleField {}
519 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
521 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
522 pub struct VariantList {
523 pub(crate) syntax: SyntaxNode,
526 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
527 pub fn variants(&self) -> AstChildren<Variant> { support::children(&self.syntax) }
528 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
530 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
532 pub(crate) syntax: SyntaxNode,
534 impl ast::AttrsOwner for Variant {}
535 impl ast::NameOwner for Variant {}
536 impl ast::VisibilityOwner for Variant {}
538 pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) }
539 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
540 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
542 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
543 pub struct AssocItemList {
544 pub(crate) syntax: SyntaxNode,
546 impl ast::AttrsOwner for AssocItemList {}
548 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
549 pub fn assoc_items(&self) -> AstChildren<AssocItem> { support::children(&self.syntax) }
550 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
552 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
553 pub struct ExternItemList {
554 pub(crate) syntax: SyntaxNode,
556 impl ast::AttrsOwner for ExternItemList {}
557 impl ExternItemList {
558 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
559 pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) }
560 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
562 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
563 pub struct ConstParam {
564 pub(crate) syntax: SyntaxNode,
566 impl ast::AttrsOwner for ConstParam {}
567 impl ast::NameOwner for ConstParam {}
569 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
570 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
571 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
572 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
573 pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) }
575 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
576 pub struct LifetimeParam {
577 pub(crate) syntax: SyntaxNode,
579 impl ast::AttrsOwner for LifetimeParam {}
580 impl ast::TypeBoundsOwner for LifetimeParam {}
582 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
583 support::token(&self.syntax, T![lifetime])
586 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
587 pub struct TypeParam {
588 pub(crate) syntax: SyntaxNode,
590 impl ast::AttrsOwner for TypeParam {}
591 impl ast::NameOwner for TypeParam {}
592 impl ast::TypeBoundsOwner for TypeParam {}
594 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
595 pub fn default_type(&self) -> Option<Type> { support::child(&self.syntax) }
597 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
598 pub struct WherePred {
599 pub(crate) syntax: SyntaxNode,
601 impl ast::TypeBoundsOwner for WherePred {}
603 pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
604 pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) }
605 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
606 support::token(&self.syntax, T![lifetime])
608 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
610 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
612 pub(crate) syntax: SyntaxNode,
614 impl ast::AttrsOwner for Literal {}
616 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
617 pub struct ExprStmt {
618 pub(crate) syntax: SyntaxNode,
620 impl ast::AttrsOwner for ExprStmt {}
622 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
623 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
625 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
627 pub(crate) syntax: SyntaxNode,
629 impl ast::AttrsOwner for LetStmt {}
631 pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }
632 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
633 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
634 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
635 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
636 pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) }
637 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
639 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
640 pub struct ArrayExpr {
641 pub(crate) syntax: SyntaxNode,
643 impl ast::AttrsOwner for ArrayExpr {}
645 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
646 pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
647 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
648 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
649 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
651 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
652 pub struct AwaitExpr {
653 pub(crate) syntax: SyntaxNode,
655 impl ast::AttrsOwner for AwaitExpr {}
657 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
658 pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
659 pub fn await_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![await]) }
661 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
663 pub(crate) syntax: SyntaxNode,
665 impl ast::AttrsOwner for BinExpr {}
667 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
669 pub(crate) syntax: SyntaxNode,
671 impl ast::AttrsOwner for BoxExpr {}
673 pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) }
674 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
676 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
677 pub struct BreakExpr {
678 pub(crate) syntax: SyntaxNode,
680 impl ast::AttrsOwner for BreakExpr {}
682 pub fn break_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![break]) }
683 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
684 support::token(&self.syntax, T![lifetime])
686 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
688 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
689 pub struct CallExpr {
690 pub(crate) syntax: SyntaxNode,
692 impl ast::AttrsOwner for CallExpr {}
693 impl ast::ArgListOwner for CallExpr {}
695 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
697 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
698 pub struct CastExpr {
699 pub(crate) syntax: SyntaxNode,
701 impl ast::AttrsOwner for CastExpr {}
703 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
704 pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
705 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
707 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
708 pub struct ClosureExpr {
709 pub(crate) syntax: SyntaxNode,
711 impl ast::AttrsOwner for ClosureExpr {}
713 pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) }
714 pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
715 pub fn move_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![move]) }
716 pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
717 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
718 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
720 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
721 pub struct ContinueExpr {
722 pub(crate) syntax: SyntaxNode,
724 impl ast::AttrsOwner for ContinueExpr {}
726 pub fn continue_token(&self) -> Option<SyntaxToken> {
727 support::token(&self.syntax, T![continue])
729 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
730 support::token(&self.syntax, T![lifetime])
733 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
734 pub struct EffectExpr {
735 pub(crate) syntax: SyntaxNode,
737 impl ast::AttrsOwner for EffectExpr {}
739 pub fn label(&self) -> Option<Label> { support::child(&self.syntax) }
740 pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) }
741 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
742 pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
743 pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
745 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
746 pub struct FieldExpr {
747 pub(crate) syntax: SyntaxNode,
749 impl ast::AttrsOwner for FieldExpr {}
751 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
752 pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
753 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
755 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
757 pub(crate) syntax: SyntaxNode,
759 impl ast::AttrsOwner for ForExpr {}
760 impl ast::LoopBodyOwner for ForExpr {}
762 pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
763 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
764 pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
765 pub fn iterable(&self) -> Option<Expr> { support::child(&self.syntax) }
767 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
769 pub(crate) syntax: SyntaxNode,
771 impl ast::AttrsOwner for IfExpr {}
773 pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }
774 pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) }
775 pub fn else_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![else]) }
777 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
778 pub struct IndexExpr {
779 pub(crate) syntax: SyntaxNode,
781 impl ast::AttrsOwner for IndexExpr {}
783 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
784 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
786 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
787 pub struct LoopExpr {
788 pub(crate) syntax: SyntaxNode,
790 impl ast::AttrsOwner for LoopExpr {}
791 impl ast::LoopBodyOwner for LoopExpr {}
793 pub fn loop_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![loop]) }
795 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
796 pub struct MatchExpr {
797 pub(crate) syntax: SyntaxNode,
799 impl ast::AttrsOwner for MatchExpr {}
801 pub fn match_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![match]) }
802 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
803 pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) }
805 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
806 pub struct MethodCallExpr {
807 pub(crate) syntax: SyntaxNode,
809 impl ast::AttrsOwner for MethodCallExpr {}
810 impl ast::ArgListOwner for MethodCallExpr {}
811 impl MethodCallExpr {
812 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
813 pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
814 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
815 pub fn generic_arg_list(&self) -> Option<GenericArgList> { support::child(&self.syntax) }
817 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
818 pub struct ParenExpr {
819 pub(crate) syntax: SyntaxNode,
821 impl ast::AttrsOwner for ParenExpr {}
823 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
824 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
825 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
827 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
828 pub struct PathExpr {
829 pub(crate) syntax: SyntaxNode,
831 impl ast::AttrsOwner for PathExpr {}
833 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
835 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
836 pub struct PrefixExpr {
837 pub(crate) syntax: SyntaxNode,
839 impl ast::AttrsOwner for PrefixExpr {}
841 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
843 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
844 pub struct RangeExpr {
845 pub(crate) syntax: SyntaxNode,
847 impl ast::AttrsOwner for RangeExpr {}
849 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
850 pub struct RecordExpr {
851 pub(crate) syntax: SyntaxNode,
854 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
855 pub fn record_expr_field_list(&self) -> Option<RecordExprFieldList> {
856 support::child(&self.syntax)
859 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
861 pub(crate) syntax: SyntaxNode,
863 impl ast::AttrsOwner for RefExpr {}
865 pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
866 pub fn raw_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![raw]) }
867 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
868 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
869 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
871 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
872 pub struct ReturnExpr {
873 pub(crate) syntax: SyntaxNode,
875 impl ast::AttrsOwner for ReturnExpr {}
877 pub fn return_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![return]) }
878 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
880 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
882 pub(crate) syntax: SyntaxNode,
884 impl ast::AttrsOwner for TryExpr {}
886 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
887 pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }
889 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
890 pub struct TupleExpr {
891 pub(crate) syntax: SyntaxNode,
893 impl ast::AttrsOwner for TupleExpr {}
895 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
896 pub fn fields(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
897 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
899 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
900 pub struct WhileExpr {
901 pub(crate) syntax: SyntaxNode,
903 impl ast::AttrsOwner for WhileExpr {}
904 impl ast::LoopBodyOwner for WhileExpr {}
906 pub fn while_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![while]) }
907 pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) }
909 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
911 pub(crate) syntax: SyntaxNode,
914 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
915 support::token(&self.syntax, T![lifetime])
918 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
919 pub struct RecordExprFieldList {
920 pub(crate) syntax: SyntaxNode,
922 impl ast::AttrsOwner for RecordExprFieldList {}
923 impl RecordExprFieldList {
924 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
925 pub fn fields(&self) -> AstChildren<RecordExprField> { support::children(&self.syntax) }
926 pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
927 pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) }
928 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
930 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
931 pub struct RecordExprField {
932 pub(crate) syntax: SyntaxNode,
934 impl ast::AttrsOwner for RecordExprField {}
935 impl RecordExprField {
936 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
937 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
938 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
940 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
942 pub(crate) syntax: SyntaxNode,
945 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
946 pub fn args(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
947 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
949 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
950 pub struct Condition {
951 pub(crate) syntax: SyntaxNode,
954 pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }
955 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
956 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
957 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
959 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
960 pub struct MatchArmList {
961 pub(crate) syntax: SyntaxNode,
963 impl ast::AttrsOwner for MatchArmList {}
965 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
966 pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) }
967 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
969 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
970 pub struct MatchArm {
971 pub(crate) syntax: SyntaxNode,
973 impl ast::AttrsOwner for MatchArm {}
975 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
976 pub fn guard(&self) -> Option<MatchGuard> { support::child(&self.syntax) }
977 pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) }
978 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
979 pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
981 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
982 pub struct MatchGuard {
983 pub(crate) syntax: SyntaxNode,
986 pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }
987 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
989 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
990 pub struct ArrayType {
991 pub(crate) syntax: SyntaxNode,
994 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
995 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
996 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
997 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
998 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1000 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1001 pub struct DynTraitType {
1002 pub(crate) syntax: SyntaxNode,
1005 pub fn dyn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![dyn]) }
1006 pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }
1008 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1009 pub struct FnPtrType {
1010 pub(crate) syntax: SyntaxNode,
1013 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
1014 pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
1015 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
1016 pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
1017 pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) }
1018 pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
1019 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
1021 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1022 pub struct ForType {
1023 pub(crate) syntax: SyntaxNode,
1026 pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
1027 pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) }
1028 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1030 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1031 pub struct ImplTraitType {
1032 pub(crate) syntax: SyntaxNode,
1034 impl ImplTraitType {
1035 pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
1036 pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }
1038 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1039 pub struct InferType {
1040 pub(crate) syntax: SyntaxNode,
1043 pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
1045 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1046 pub struct NeverType {
1047 pub(crate) syntax: SyntaxNode,
1050 pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
1052 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1053 pub struct ParenType {
1054 pub(crate) syntax: SyntaxNode,
1057 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1058 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1059 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1061 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1062 pub struct PtrType {
1063 pub(crate) syntax: SyntaxNode,
1066 pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
1067 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
1068 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1069 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1071 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1072 pub struct RefType {
1073 pub(crate) syntax: SyntaxNode,
1076 pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
1077 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
1078 support::token(&self.syntax, T![lifetime])
1080 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1081 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1083 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1084 pub struct SliceType {
1085 pub(crate) syntax: SyntaxNode,
1088 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
1089 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1090 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1092 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1093 pub struct TupleType {
1094 pub(crate) syntax: SyntaxNode,
1097 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1098 pub fn fields(&self) -> AstChildren<Type> { support::children(&self.syntax) }
1099 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1101 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1102 pub struct TypeBound {
1103 pub(crate) syntax: SyntaxNode,
1106 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
1107 support::token(&self.syntax, T![lifetime])
1109 pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }
1110 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1112 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1113 pub struct IdentPat {
1114 pub(crate) syntax: SyntaxNode,
1116 impl ast::AttrsOwner for IdentPat {}
1117 impl ast::NameOwner for IdentPat {}
1119 pub fn ref_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ref]) }
1120 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1121 pub fn at_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![@]) }
1122 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1124 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1126 pub(crate) syntax: SyntaxNode,
1129 pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) }
1130 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1132 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1133 pub struct RestPat {
1134 pub(crate) syntax: SyntaxNode,
1137 pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
1139 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1140 pub struct LiteralPat {
1141 pub(crate) syntax: SyntaxNode,
1144 pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
1146 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1147 pub struct MacroPat {
1148 pub(crate) syntax: SyntaxNode,
1151 pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
1153 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1155 pub(crate) syntax: SyntaxNode,
1158 pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1160 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1161 pub struct ParenPat {
1162 pub(crate) syntax: SyntaxNode,
1165 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1166 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1167 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1169 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1170 pub struct PathPat {
1171 pub(crate) syntax: SyntaxNode,
1174 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1176 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1177 pub struct WildcardPat {
1178 pub(crate) syntax: SyntaxNode,
1181 pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
1183 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1184 pub struct RangePat {
1185 pub(crate) syntax: SyntaxNode,
1188 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1189 pub struct RecordPat {
1190 pub(crate) syntax: SyntaxNode,
1193 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1194 pub fn record_pat_field_list(&self) -> Option<RecordPatFieldList> {
1195 support::child(&self.syntax)
1198 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1200 pub(crate) syntax: SyntaxNode,
1203 pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
1204 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1205 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1207 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1208 pub struct SlicePat {
1209 pub(crate) syntax: SyntaxNode,
1212 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
1213 pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1214 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1216 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1217 pub struct TuplePat {
1218 pub(crate) syntax: SyntaxNode,
1221 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1222 pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1223 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1225 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1226 pub struct TupleStructPat {
1227 pub(crate) syntax: SyntaxNode,
1229 impl TupleStructPat {
1230 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1231 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1232 pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1233 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1235 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1236 pub struct RecordPatFieldList {
1237 pub(crate) syntax: SyntaxNode,
1239 impl RecordPatFieldList {
1240 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
1241 pub fn fields(&self) -> AstChildren<RecordPatField> { support::children(&self.syntax) }
1242 pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
1243 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1245 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1246 pub struct RecordPatField {
1247 pub(crate) syntax: SyntaxNode,
1249 impl ast::AttrsOwner for RecordPatField {}
1250 impl RecordPatField {
1251 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
1252 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
1253 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1255 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1256 pub enum GenericArg {
1258 AssocTypeArg(AssocTypeArg),
1259 LifetimeArg(LifetimeArg),
1262 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1264 ArrayType(ArrayType),
1265 DynTraitType(DynTraitType),
1266 FnPtrType(FnPtrType),
1268 ImplTraitType(ImplTraitType),
1269 InferType(InferType),
1270 NeverType(NeverType),
1271 ParenType(ParenType),
1275 SliceType(SliceType),
1276 TupleType(TupleType),
1278 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1280 ArrayExpr(ArrayExpr),
1281 AwaitExpr(AwaitExpr),
1283 BlockExpr(BlockExpr),
1285 BreakExpr(BreakExpr),
1288 ClosureExpr(ClosureExpr),
1289 ContinueExpr(ContinueExpr),
1290 EffectExpr(EffectExpr),
1291 FieldExpr(FieldExpr),
1294 IndexExpr(IndexExpr),
1297 MacroCall(MacroCall),
1298 MatchExpr(MatchExpr),
1299 MethodCallExpr(MethodCallExpr),
1300 ParenExpr(ParenExpr),
1302 PrefixExpr(PrefixExpr),
1303 RangeExpr(RangeExpr),
1304 RecordExpr(RecordExpr),
1306 ReturnExpr(ReturnExpr),
1308 TupleExpr(TupleExpr),
1309 WhileExpr(WhileExpr),
1311 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1315 ExternBlock(ExternBlock),
1316 ExternCrate(ExternCrate),
1319 MacroCall(MacroCall),
1324 TypeAlias(TypeAlias),
1328 impl ast::AttrsOwner for Item {}
1329 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1335 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1340 LiteralPat(LiteralPat),
1345 WildcardPat(WildcardPat),
1347 RecordPat(RecordPat),
1351 TupleStructPat(TupleStructPat),
1353 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1354 pub enum FieldList {
1355 RecordFieldList(RecordFieldList),
1356 TupleFieldList(TupleFieldList),
1358 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1364 impl ast::AttrsOwner for AdtDef {}
1365 impl ast::GenericParamsOwner for AdtDef {}
1366 impl ast::NameOwner for AdtDef {}
1367 impl ast::VisibilityOwner for AdtDef {}
1368 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1369 pub enum AssocItem {
1372 MacroCall(MacroCall),
1373 TypeAlias(TypeAlias),
1375 impl ast::AttrsOwner for AssocItem {}
1376 impl ast::NameOwner for AssocItem {}
1377 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1378 pub enum ExternItem {
1380 MacroCall(MacroCall),
1383 impl ast::AttrsOwner for ExternItem {}
1384 impl ast::NameOwner for ExternItem {}
1385 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
1386 pub enum GenericParam {
1387 ConstParam(ConstParam),
1388 LifetimeParam(LifetimeParam),
1389 TypeParam(TypeParam),
1391 impl ast::AttrsOwner for GenericParam {}
1392 impl AstNode for Name {
1393 fn can_cast(kind: SyntaxKind) -> bool { kind == NAME }
1394 fn cast(syntax: SyntaxNode) -> Option<Self> {
1395 if Self::can_cast(syntax.kind()) {
1396 Some(Self { syntax })
1401 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1403 impl AstNode for NameRef {
1404 fn can_cast(kind: SyntaxKind) -> bool { kind == NAME_REF }
1405 fn cast(syntax: SyntaxNode) -> Option<Self> {
1406 if Self::can_cast(syntax.kind()) {
1407 Some(Self { syntax })
1412 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1414 impl AstNode for Path {
1415 fn can_cast(kind: SyntaxKind) -> bool { kind == PATH }
1416 fn cast(syntax: SyntaxNode) -> Option<Self> {
1417 if Self::can_cast(syntax.kind()) {
1418 Some(Self { syntax })
1423 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1425 impl AstNode for PathSegment {
1426 fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_SEGMENT }
1427 fn cast(syntax: SyntaxNode) -> Option<Self> {
1428 if Self::can_cast(syntax.kind()) {
1429 Some(Self { syntax })
1434 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1436 impl AstNode for GenericArgList {
1437 fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_ARG_LIST }
1438 fn cast(syntax: SyntaxNode) -> Option<Self> {
1439 if Self::can_cast(syntax.kind()) {
1440 Some(Self { syntax })
1445 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1447 impl AstNode for ParamList {
1448 fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM_LIST }
1449 fn cast(syntax: SyntaxNode) -> Option<Self> {
1450 if Self::can_cast(syntax.kind()) {
1451 Some(Self { syntax })
1456 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1458 impl AstNode for RetType {
1459 fn can_cast(kind: SyntaxKind) -> bool { kind == RET_TYPE }
1460 fn cast(syntax: SyntaxNode) -> Option<Self> {
1461 if Self::can_cast(syntax.kind()) {
1462 Some(Self { syntax })
1467 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1469 impl AstNode for PathType {
1470 fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_TYPE }
1471 fn cast(syntax: SyntaxNode) -> Option<Self> {
1472 if Self::can_cast(syntax.kind()) {
1473 Some(Self { syntax })
1478 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1480 impl AstNode for TypeArg {
1481 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ARG }
1482 fn cast(syntax: SyntaxNode) -> Option<Self> {
1483 if Self::can_cast(syntax.kind()) {
1484 Some(Self { syntax })
1489 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1491 impl AstNode for AssocTypeArg {
1492 fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_TYPE_ARG }
1493 fn cast(syntax: SyntaxNode) -> Option<Self> {
1494 if Self::can_cast(syntax.kind()) {
1495 Some(Self { syntax })
1500 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1502 impl AstNode for LifetimeArg {
1503 fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_ARG }
1504 fn cast(syntax: SyntaxNode) -> Option<Self> {
1505 if Self::can_cast(syntax.kind()) {
1506 Some(Self { syntax })
1511 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1513 impl AstNode for ConstArg {
1514 fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_ARG }
1515 fn cast(syntax: SyntaxNode) -> Option<Self> {
1516 if Self::can_cast(syntax.kind()) {
1517 Some(Self { syntax })
1522 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1524 impl AstNode for TypeBoundList {
1525 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND_LIST }
1526 fn cast(syntax: SyntaxNode) -> Option<Self> {
1527 if Self::can_cast(syntax.kind()) {
1528 Some(Self { syntax })
1533 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1535 impl AstNode for MacroCall {
1536 fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_CALL }
1537 fn cast(syntax: SyntaxNode) -> Option<Self> {
1538 if Self::can_cast(syntax.kind()) {
1539 Some(Self { syntax })
1544 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1546 impl AstNode for Attr {
1547 fn can_cast(kind: SyntaxKind) -> bool { kind == ATTR }
1548 fn cast(syntax: SyntaxNode) -> Option<Self> {
1549 if Self::can_cast(syntax.kind()) {
1550 Some(Self { syntax })
1555 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1557 impl AstNode for TokenTree {
1558 fn can_cast(kind: SyntaxKind) -> bool { kind == TOKEN_TREE }
1559 fn cast(syntax: SyntaxNode) -> Option<Self> {
1560 if Self::can_cast(syntax.kind()) {
1561 Some(Self { syntax })
1566 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1568 impl AstNode for MacroItems {
1569 fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_ITEMS }
1570 fn cast(syntax: SyntaxNode) -> Option<Self> {
1571 if Self::can_cast(syntax.kind()) {
1572 Some(Self { syntax })
1577 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1579 impl AstNode for MacroStmts {
1580 fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_STMTS }
1581 fn cast(syntax: SyntaxNode) -> Option<Self> {
1582 if Self::can_cast(syntax.kind()) {
1583 Some(Self { syntax })
1588 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1590 impl AstNode for SourceFile {
1591 fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE }
1592 fn cast(syntax: SyntaxNode) -> Option<Self> {
1593 if Self::can_cast(syntax.kind()) {
1594 Some(Self { syntax })
1599 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1601 impl AstNode for Const {
1602 fn can_cast(kind: SyntaxKind) -> bool { kind == CONST }
1603 fn cast(syntax: SyntaxNode) -> Option<Self> {
1604 if Self::can_cast(syntax.kind()) {
1605 Some(Self { syntax })
1610 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1612 impl AstNode for Enum {
1613 fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM }
1614 fn cast(syntax: SyntaxNode) -> Option<Self> {
1615 if Self::can_cast(syntax.kind()) {
1616 Some(Self { syntax })
1621 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1623 impl AstNode for ExternBlock {
1624 fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_BLOCK }
1625 fn cast(syntax: SyntaxNode) -> Option<Self> {
1626 if Self::can_cast(syntax.kind()) {
1627 Some(Self { syntax })
1632 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1634 impl AstNode for ExternCrate {
1635 fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_CRATE }
1636 fn cast(syntax: SyntaxNode) -> Option<Self> {
1637 if Self::can_cast(syntax.kind()) {
1638 Some(Self { syntax })
1643 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1645 impl AstNode for Fn {
1646 fn can_cast(kind: SyntaxKind) -> bool { kind == FN }
1647 fn cast(syntax: SyntaxNode) -> Option<Self> {
1648 if Self::can_cast(syntax.kind()) {
1649 Some(Self { syntax })
1654 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1656 impl AstNode for Impl {
1657 fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL }
1658 fn cast(syntax: SyntaxNode) -> Option<Self> {
1659 if Self::can_cast(syntax.kind()) {
1660 Some(Self { syntax })
1665 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1667 impl AstNode for Module {
1668 fn can_cast(kind: SyntaxKind) -> bool { kind == MODULE }
1669 fn cast(syntax: SyntaxNode) -> Option<Self> {
1670 if Self::can_cast(syntax.kind()) {
1671 Some(Self { syntax })
1676 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1678 impl AstNode for Static {
1679 fn can_cast(kind: SyntaxKind) -> bool { kind == STATIC }
1680 fn cast(syntax: SyntaxNode) -> Option<Self> {
1681 if Self::can_cast(syntax.kind()) {
1682 Some(Self { syntax })
1687 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1689 impl AstNode for Struct {
1690 fn can_cast(kind: SyntaxKind) -> bool { kind == STRUCT }
1691 fn cast(syntax: SyntaxNode) -> Option<Self> {
1692 if Self::can_cast(syntax.kind()) {
1693 Some(Self { syntax })
1698 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1700 impl AstNode for Trait {
1701 fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT }
1702 fn cast(syntax: SyntaxNode) -> Option<Self> {
1703 if Self::can_cast(syntax.kind()) {
1704 Some(Self { syntax })
1709 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1711 impl AstNode for TypeAlias {
1712 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ALIAS }
1713 fn cast(syntax: SyntaxNode) -> Option<Self> {
1714 if Self::can_cast(syntax.kind()) {
1715 Some(Self { syntax })
1720 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1722 impl AstNode for Union {
1723 fn can_cast(kind: SyntaxKind) -> bool { kind == UNION }
1724 fn cast(syntax: SyntaxNode) -> Option<Self> {
1725 if Self::can_cast(syntax.kind()) {
1726 Some(Self { syntax })
1731 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1733 impl AstNode for Use {
1734 fn can_cast(kind: SyntaxKind) -> bool { kind == USE }
1735 fn cast(syntax: SyntaxNode) -> Option<Self> {
1736 if Self::can_cast(syntax.kind()) {
1737 Some(Self { syntax })
1742 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1744 impl AstNode for Visibility {
1745 fn can_cast(kind: SyntaxKind) -> bool { kind == VISIBILITY }
1746 fn cast(syntax: SyntaxNode) -> Option<Self> {
1747 if Self::can_cast(syntax.kind()) {
1748 Some(Self { syntax })
1753 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1755 impl AstNode for ItemList {
1756 fn can_cast(kind: SyntaxKind) -> bool { kind == ITEM_LIST }
1757 fn cast(syntax: SyntaxNode) -> Option<Self> {
1758 if Self::can_cast(syntax.kind()) {
1759 Some(Self { syntax })
1764 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1766 impl AstNode for Rename {
1767 fn can_cast(kind: SyntaxKind) -> bool { kind == RENAME }
1768 fn cast(syntax: SyntaxNode) -> Option<Self> {
1769 if Self::can_cast(syntax.kind()) {
1770 Some(Self { syntax })
1775 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1777 impl AstNode for UseTree {
1778 fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE }
1779 fn cast(syntax: SyntaxNode) -> Option<Self> {
1780 if Self::can_cast(syntax.kind()) {
1781 Some(Self { syntax })
1786 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1788 impl AstNode for UseTreeList {
1789 fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE_LIST }
1790 fn cast(syntax: SyntaxNode) -> Option<Self> {
1791 if Self::can_cast(syntax.kind()) {
1792 Some(Self { syntax })
1797 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1799 impl AstNode for Abi {
1800 fn can_cast(kind: SyntaxKind) -> bool { kind == ABI }
1801 fn cast(syntax: SyntaxNode) -> Option<Self> {
1802 if Self::can_cast(syntax.kind()) {
1803 Some(Self { syntax })
1808 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1810 impl AstNode for GenericParamList {
1811 fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_PARAM_LIST }
1812 fn cast(syntax: SyntaxNode) -> Option<Self> {
1813 if Self::can_cast(syntax.kind()) {
1814 Some(Self { syntax })
1819 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1821 impl AstNode for WhereClause {
1822 fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_CLAUSE }
1823 fn cast(syntax: SyntaxNode) -> Option<Self> {
1824 if Self::can_cast(syntax.kind()) {
1825 Some(Self { syntax })
1830 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1832 impl AstNode for BlockExpr {
1833 fn can_cast(kind: SyntaxKind) -> bool { kind == BLOCK_EXPR }
1834 fn cast(syntax: SyntaxNode) -> Option<Self> {
1835 if Self::can_cast(syntax.kind()) {
1836 Some(Self { syntax })
1841 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1843 impl AstNode for SelfParam {
1844 fn can_cast(kind: SyntaxKind) -> bool { kind == SELF_PARAM }
1845 fn cast(syntax: SyntaxNode) -> Option<Self> {
1846 if Self::can_cast(syntax.kind()) {
1847 Some(Self { syntax })
1852 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1854 impl AstNode for Param {
1855 fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM }
1856 fn cast(syntax: SyntaxNode) -> Option<Self> {
1857 if Self::can_cast(syntax.kind()) {
1858 Some(Self { syntax })
1863 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1865 impl AstNode for RecordFieldList {
1866 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_LIST }
1867 fn cast(syntax: SyntaxNode) -> Option<Self> {
1868 if Self::can_cast(syntax.kind()) {
1869 Some(Self { syntax })
1874 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1876 impl AstNode for TupleFieldList {
1877 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD_LIST }
1878 fn cast(syntax: SyntaxNode) -> Option<Self> {
1879 if Self::can_cast(syntax.kind()) {
1880 Some(Self { syntax })
1885 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1887 impl AstNode for RecordField {
1888 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD }
1889 fn cast(syntax: SyntaxNode) -> Option<Self> {
1890 if Self::can_cast(syntax.kind()) {
1891 Some(Self { syntax })
1896 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1898 impl AstNode for TupleField {
1899 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD }
1900 fn cast(syntax: SyntaxNode) -> Option<Self> {
1901 if Self::can_cast(syntax.kind()) {
1902 Some(Self { syntax })
1907 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1909 impl AstNode for VariantList {
1910 fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT_LIST }
1911 fn cast(syntax: SyntaxNode) -> Option<Self> {
1912 if Self::can_cast(syntax.kind()) {
1913 Some(Self { syntax })
1918 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1920 impl AstNode for Variant {
1921 fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT }
1922 fn cast(syntax: SyntaxNode) -> Option<Self> {
1923 if Self::can_cast(syntax.kind()) {
1924 Some(Self { syntax })
1929 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1931 impl AstNode for AssocItemList {
1932 fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_ITEM_LIST }
1933 fn cast(syntax: SyntaxNode) -> Option<Self> {
1934 if Self::can_cast(syntax.kind()) {
1935 Some(Self { syntax })
1940 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1942 impl AstNode for ExternItemList {
1943 fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_ITEM_LIST }
1944 fn cast(syntax: SyntaxNode) -> Option<Self> {
1945 if Self::can_cast(syntax.kind()) {
1946 Some(Self { syntax })
1951 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1953 impl AstNode for ConstParam {
1954 fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_PARAM }
1955 fn cast(syntax: SyntaxNode) -> Option<Self> {
1956 if Self::can_cast(syntax.kind()) {
1957 Some(Self { syntax })
1962 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1964 impl AstNode for LifetimeParam {
1965 fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_PARAM }
1966 fn cast(syntax: SyntaxNode) -> Option<Self> {
1967 if Self::can_cast(syntax.kind()) {
1968 Some(Self { syntax })
1973 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1975 impl AstNode for TypeParam {
1976 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_PARAM }
1977 fn cast(syntax: SyntaxNode) -> Option<Self> {
1978 if Self::can_cast(syntax.kind()) {
1979 Some(Self { syntax })
1984 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1986 impl AstNode for WherePred {
1987 fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_PRED }
1988 fn cast(syntax: SyntaxNode) -> Option<Self> {
1989 if Self::can_cast(syntax.kind()) {
1990 Some(Self { syntax })
1995 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1997 impl AstNode for Literal {
1998 fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL }
1999 fn cast(syntax: SyntaxNode) -> Option<Self> {
2000 if Self::can_cast(syntax.kind()) {
2001 Some(Self { syntax })
2006 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2008 impl AstNode for ExprStmt {
2009 fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_STMT }
2010 fn cast(syntax: SyntaxNode) -> Option<Self> {
2011 if Self::can_cast(syntax.kind()) {
2012 Some(Self { syntax })
2017 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2019 impl AstNode for LetStmt {
2020 fn can_cast(kind: SyntaxKind) -> bool { kind == LET_STMT }
2021 fn cast(syntax: SyntaxNode) -> Option<Self> {
2022 if Self::can_cast(syntax.kind()) {
2023 Some(Self { syntax })
2028 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2030 impl AstNode for ArrayExpr {
2031 fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_EXPR }
2032 fn cast(syntax: SyntaxNode) -> Option<Self> {
2033 if Self::can_cast(syntax.kind()) {
2034 Some(Self { syntax })
2039 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2041 impl AstNode for AwaitExpr {
2042 fn can_cast(kind: SyntaxKind) -> bool { kind == AWAIT_EXPR }
2043 fn cast(syntax: SyntaxNode) -> Option<Self> {
2044 if Self::can_cast(syntax.kind()) {
2045 Some(Self { syntax })
2050 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2052 impl AstNode for BinExpr {
2053 fn can_cast(kind: SyntaxKind) -> bool { kind == BIN_EXPR }
2054 fn cast(syntax: SyntaxNode) -> Option<Self> {
2055 if Self::can_cast(syntax.kind()) {
2056 Some(Self { syntax })
2061 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2063 impl AstNode for BoxExpr {
2064 fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_EXPR }
2065 fn cast(syntax: SyntaxNode) -> Option<Self> {
2066 if Self::can_cast(syntax.kind()) {
2067 Some(Self { syntax })
2072 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2074 impl AstNode for BreakExpr {
2075 fn can_cast(kind: SyntaxKind) -> bool { kind == BREAK_EXPR }
2076 fn cast(syntax: SyntaxNode) -> Option<Self> {
2077 if Self::can_cast(syntax.kind()) {
2078 Some(Self { syntax })
2083 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2085 impl AstNode for CallExpr {
2086 fn can_cast(kind: SyntaxKind) -> bool { kind == CALL_EXPR }
2087 fn cast(syntax: SyntaxNode) -> Option<Self> {
2088 if Self::can_cast(syntax.kind()) {
2089 Some(Self { syntax })
2094 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2096 impl AstNode for CastExpr {
2097 fn can_cast(kind: SyntaxKind) -> bool { kind == CAST_EXPR }
2098 fn cast(syntax: SyntaxNode) -> Option<Self> {
2099 if Self::can_cast(syntax.kind()) {
2100 Some(Self { syntax })
2105 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2107 impl AstNode for ClosureExpr {
2108 fn can_cast(kind: SyntaxKind) -> bool { kind == CLOSURE_EXPR }
2109 fn cast(syntax: SyntaxNode) -> Option<Self> {
2110 if Self::can_cast(syntax.kind()) {
2111 Some(Self { syntax })
2116 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2118 impl AstNode for ContinueExpr {
2119 fn can_cast(kind: SyntaxKind) -> bool { kind == CONTINUE_EXPR }
2120 fn cast(syntax: SyntaxNode) -> Option<Self> {
2121 if Self::can_cast(syntax.kind()) {
2122 Some(Self { syntax })
2127 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2129 impl AstNode for EffectExpr {
2130 fn can_cast(kind: SyntaxKind) -> bool { kind == EFFECT_EXPR }
2131 fn cast(syntax: SyntaxNode) -> Option<Self> {
2132 if Self::can_cast(syntax.kind()) {
2133 Some(Self { syntax })
2138 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2140 impl AstNode for FieldExpr {
2141 fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_EXPR }
2142 fn cast(syntax: SyntaxNode) -> Option<Self> {
2143 if Self::can_cast(syntax.kind()) {
2144 Some(Self { syntax })
2149 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2151 impl AstNode for ForExpr {
2152 fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_EXPR }
2153 fn cast(syntax: SyntaxNode) -> Option<Self> {
2154 if Self::can_cast(syntax.kind()) {
2155 Some(Self { syntax })
2160 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2162 impl AstNode for IfExpr {
2163 fn can_cast(kind: SyntaxKind) -> bool { kind == IF_EXPR }
2164 fn cast(syntax: SyntaxNode) -> Option<Self> {
2165 if Self::can_cast(syntax.kind()) {
2166 Some(Self { syntax })
2171 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2173 impl AstNode for IndexExpr {
2174 fn can_cast(kind: SyntaxKind) -> bool { kind == INDEX_EXPR }
2175 fn cast(syntax: SyntaxNode) -> Option<Self> {
2176 if Self::can_cast(syntax.kind()) {
2177 Some(Self { syntax })
2182 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2184 impl AstNode for LoopExpr {
2185 fn can_cast(kind: SyntaxKind) -> bool { kind == LOOP_EXPR }
2186 fn cast(syntax: SyntaxNode) -> Option<Self> {
2187 if Self::can_cast(syntax.kind()) {
2188 Some(Self { syntax })
2193 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2195 impl AstNode for MatchExpr {
2196 fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_EXPR }
2197 fn cast(syntax: SyntaxNode) -> Option<Self> {
2198 if Self::can_cast(syntax.kind()) {
2199 Some(Self { syntax })
2204 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2206 impl AstNode for MethodCallExpr {
2207 fn can_cast(kind: SyntaxKind) -> bool { kind == METHOD_CALL_EXPR }
2208 fn cast(syntax: SyntaxNode) -> Option<Self> {
2209 if Self::can_cast(syntax.kind()) {
2210 Some(Self { syntax })
2215 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2217 impl AstNode for ParenExpr {
2218 fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_EXPR }
2219 fn cast(syntax: SyntaxNode) -> Option<Self> {
2220 if Self::can_cast(syntax.kind()) {
2221 Some(Self { syntax })
2226 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2228 impl AstNode for PathExpr {
2229 fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_EXPR }
2230 fn cast(syntax: SyntaxNode) -> Option<Self> {
2231 if Self::can_cast(syntax.kind()) {
2232 Some(Self { syntax })
2237 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2239 impl AstNode for PrefixExpr {
2240 fn can_cast(kind: SyntaxKind) -> bool { kind == PREFIX_EXPR }
2241 fn cast(syntax: SyntaxNode) -> Option<Self> {
2242 if Self::can_cast(syntax.kind()) {
2243 Some(Self { syntax })
2248 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2250 impl AstNode for RangeExpr {
2251 fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_EXPR }
2252 fn cast(syntax: SyntaxNode) -> Option<Self> {
2253 if Self::can_cast(syntax.kind()) {
2254 Some(Self { syntax })
2259 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2261 impl AstNode for RecordExpr {
2262 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR }
2263 fn cast(syntax: SyntaxNode) -> Option<Self> {
2264 if Self::can_cast(syntax.kind()) {
2265 Some(Self { syntax })
2270 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2272 impl AstNode for RefExpr {
2273 fn can_cast(kind: SyntaxKind) -> bool { kind == REF_EXPR }
2274 fn cast(syntax: SyntaxNode) -> Option<Self> {
2275 if Self::can_cast(syntax.kind()) {
2276 Some(Self { syntax })
2281 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2283 impl AstNode for ReturnExpr {
2284 fn can_cast(kind: SyntaxKind) -> bool { kind == RETURN_EXPR }
2285 fn cast(syntax: SyntaxNode) -> Option<Self> {
2286 if Self::can_cast(syntax.kind()) {
2287 Some(Self { syntax })
2292 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2294 impl AstNode for TryExpr {
2295 fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_EXPR }
2296 fn cast(syntax: SyntaxNode) -> Option<Self> {
2297 if Self::can_cast(syntax.kind()) {
2298 Some(Self { syntax })
2303 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2305 impl AstNode for TupleExpr {
2306 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_EXPR }
2307 fn cast(syntax: SyntaxNode) -> Option<Self> {
2308 if Self::can_cast(syntax.kind()) {
2309 Some(Self { syntax })
2314 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2316 impl AstNode for WhileExpr {
2317 fn can_cast(kind: SyntaxKind) -> bool { kind == WHILE_EXPR }
2318 fn cast(syntax: SyntaxNode) -> Option<Self> {
2319 if Self::can_cast(syntax.kind()) {
2320 Some(Self { syntax })
2325 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2327 impl AstNode for Label {
2328 fn can_cast(kind: SyntaxKind) -> bool { kind == LABEL }
2329 fn cast(syntax: SyntaxNode) -> Option<Self> {
2330 if Self::can_cast(syntax.kind()) {
2331 Some(Self { syntax })
2336 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2338 impl AstNode for RecordExprFieldList {
2339 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD_LIST }
2340 fn cast(syntax: SyntaxNode) -> Option<Self> {
2341 if Self::can_cast(syntax.kind()) {
2342 Some(Self { syntax })
2347 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2349 impl AstNode for RecordExprField {
2350 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD }
2351 fn cast(syntax: SyntaxNode) -> Option<Self> {
2352 if Self::can_cast(syntax.kind()) {
2353 Some(Self { syntax })
2358 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2360 impl AstNode for ArgList {
2361 fn can_cast(kind: SyntaxKind) -> bool { kind == ARG_LIST }
2362 fn cast(syntax: SyntaxNode) -> Option<Self> {
2363 if Self::can_cast(syntax.kind()) {
2364 Some(Self { syntax })
2369 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2371 impl AstNode for Condition {
2372 fn can_cast(kind: SyntaxKind) -> bool { kind == CONDITION }
2373 fn cast(syntax: SyntaxNode) -> Option<Self> {
2374 if Self::can_cast(syntax.kind()) {
2375 Some(Self { syntax })
2380 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2382 impl AstNode for MatchArmList {
2383 fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM_LIST }
2384 fn cast(syntax: SyntaxNode) -> Option<Self> {
2385 if Self::can_cast(syntax.kind()) {
2386 Some(Self { syntax })
2391 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2393 impl AstNode for MatchArm {
2394 fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM }
2395 fn cast(syntax: SyntaxNode) -> Option<Self> {
2396 if Self::can_cast(syntax.kind()) {
2397 Some(Self { syntax })
2402 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2404 impl AstNode for MatchGuard {
2405 fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_GUARD }
2406 fn cast(syntax: SyntaxNode) -> Option<Self> {
2407 if Self::can_cast(syntax.kind()) {
2408 Some(Self { syntax })
2413 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2415 impl AstNode for ArrayType {
2416 fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_TYPE }
2417 fn cast(syntax: SyntaxNode) -> Option<Self> {
2418 if Self::can_cast(syntax.kind()) {
2419 Some(Self { syntax })
2424 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2426 impl AstNode for DynTraitType {
2427 fn can_cast(kind: SyntaxKind) -> bool { kind == DYN_TRAIT_TYPE }
2428 fn cast(syntax: SyntaxNode) -> Option<Self> {
2429 if Self::can_cast(syntax.kind()) {
2430 Some(Self { syntax })
2435 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2437 impl AstNode for FnPtrType {
2438 fn can_cast(kind: SyntaxKind) -> bool { kind == FN_PTR_TYPE }
2439 fn cast(syntax: SyntaxNode) -> Option<Self> {
2440 if Self::can_cast(syntax.kind()) {
2441 Some(Self { syntax })
2446 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2448 impl AstNode for ForType {
2449 fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_TYPE }
2450 fn cast(syntax: SyntaxNode) -> Option<Self> {
2451 if Self::can_cast(syntax.kind()) {
2452 Some(Self { syntax })
2457 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2459 impl AstNode for ImplTraitType {
2460 fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_TRAIT_TYPE }
2461 fn cast(syntax: SyntaxNode) -> Option<Self> {
2462 if Self::can_cast(syntax.kind()) {
2463 Some(Self { syntax })
2468 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2470 impl AstNode for InferType {
2471 fn can_cast(kind: SyntaxKind) -> bool { kind == INFER_TYPE }
2472 fn cast(syntax: SyntaxNode) -> Option<Self> {
2473 if Self::can_cast(syntax.kind()) {
2474 Some(Self { syntax })
2479 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2481 impl AstNode for NeverType {
2482 fn can_cast(kind: SyntaxKind) -> bool { kind == NEVER_TYPE }
2483 fn cast(syntax: SyntaxNode) -> Option<Self> {
2484 if Self::can_cast(syntax.kind()) {
2485 Some(Self { syntax })
2490 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2492 impl AstNode for ParenType {
2493 fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_TYPE }
2494 fn cast(syntax: SyntaxNode) -> Option<Self> {
2495 if Self::can_cast(syntax.kind()) {
2496 Some(Self { syntax })
2501 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2503 impl AstNode for PtrType {
2504 fn can_cast(kind: SyntaxKind) -> bool { kind == PTR_TYPE }
2505 fn cast(syntax: SyntaxNode) -> Option<Self> {
2506 if Self::can_cast(syntax.kind()) {
2507 Some(Self { syntax })
2512 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2514 impl AstNode for RefType {
2515 fn can_cast(kind: SyntaxKind) -> bool { kind == REF_TYPE }
2516 fn cast(syntax: SyntaxNode) -> Option<Self> {
2517 if Self::can_cast(syntax.kind()) {
2518 Some(Self { syntax })
2523 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2525 impl AstNode for SliceType {
2526 fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_TYPE }
2527 fn cast(syntax: SyntaxNode) -> Option<Self> {
2528 if Self::can_cast(syntax.kind()) {
2529 Some(Self { syntax })
2534 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2536 impl AstNode for TupleType {
2537 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_TYPE }
2538 fn cast(syntax: SyntaxNode) -> Option<Self> {
2539 if Self::can_cast(syntax.kind()) {
2540 Some(Self { syntax })
2545 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2547 impl AstNode for TypeBound {
2548 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND }
2549 fn cast(syntax: SyntaxNode) -> Option<Self> {
2550 if Self::can_cast(syntax.kind()) {
2551 Some(Self { syntax })
2556 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2558 impl AstNode for IdentPat {
2559 fn can_cast(kind: SyntaxKind) -> bool { kind == IDENT_PAT }
2560 fn cast(syntax: SyntaxNode) -> Option<Self> {
2561 if Self::can_cast(syntax.kind()) {
2562 Some(Self { syntax })
2567 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2569 impl AstNode for BoxPat {
2570 fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_PAT }
2571 fn cast(syntax: SyntaxNode) -> Option<Self> {
2572 if Self::can_cast(syntax.kind()) {
2573 Some(Self { syntax })
2578 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2580 impl AstNode for RestPat {
2581 fn can_cast(kind: SyntaxKind) -> bool { kind == REST_PAT }
2582 fn cast(syntax: SyntaxNode) -> Option<Self> {
2583 if Self::can_cast(syntax.kind()) {
2584 Some(Self { syntax })
2589 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2591 impl AstNode for LiteralPat {
2592 fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL_PAT }
2593 fn cast(syntax: SyntaxNode) -> Option<Self> {
2594 if Self::can_cast(syntax.kind()) {
2595 Some(Self { syntax })
2600 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2602 impl AstNode for MacroPat {
2603 fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_PAT }
2604 fn cast(syntax: SyntaxNode) -> Option<Self> {
2605 if Self::can_cast(syntax.kind()) {
2606 Some(Self { syntax })
2611 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2613 impl AstNode for OrPat {
2614 fn can_cast(kind: SyntaxKind) -> bool { kind == OR_PAT }
2615 fn cast(syntax: SyntaxNode) -> Option<Self> {
2616 if Self::can_cast(syntax.kind()) {
2617 Some(Self { syntax })
2622 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2624 impl AstNode for ParenPat {
2625 fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_PAT }
2626 fn cast(syntax: SyntaxNode) -> Option<Self> {
2627 if Self::can_cast(syntax.kind()) {
2628 Some(Self { syntax })
2633 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2635 impl AstNode for PathPat {
2636 fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_PAT }
2637 fn cast(syntax: SyntaxNode) -> Option<Self> {
2638 if Self::can_cast(syntax.kind()) {
2639 Some(Self { syntax })
2644 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2646 impl AstNode for WildcardPat {
2647 fn can_cast(kind: SyntaxKind) -> bool { kind == WILDCARD_PAT }
2648 fn cast(syntax: SyntaxNode) -> Option<Self> {
2649 if Self::can_cast(syntax.kind()) {
2650 Some(Self { syntax })
2655 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2657 impl AstNode for RangePat {
2658 fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_PAT }
2659 fn cast(syntax: SyntaxNode) -> Option<Self> {
2660 if Self::can_cast(syntax.kind()) {
2661 Some(Self { syntax })
2666 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2668 impl AstNode for RecordPat {
2669 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT }
2670 fn cast(syntax: SyntaxNode) -> Option<Self> {
2671 if Self::can_cast(syntax.kind()) {
2672 Some(Self { syntax })
2677 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2679 impl AstNode for RefPat {
2680 fn can_cast(kind: SyntaxKind) -> bool { kind == REF_PAT }
2681 fn cast(syntax: SyntaxNode) -> Option<Self> {
2682 if Self::can_cast(syntax.kind()) {
2683 Some(Self { syntax })
2688 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2690 impl AstNode for SlicePat {
2691 fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_PAT }
2692 fn cast(syntax: SyntaxNode) -> Option<Self> {
2693 if Self::can_cast(syntax.kind()) {
2694 Some(Self { syntax })
2699 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2701 impl AstNode for TuplePat {
2702 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_PAT }
2703 fn cast(syntax: SyntaxNode) -> Option<Self> {
2704 if Self::can_cast(syntax.kind()) {
2705 Some(Self { syntax })
2710 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2712 impl AstNode for TupleStructPat {
2713 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_STRUCT_PAT }
2714 fn cast(syntax: SyntaxNode) -> Option<Self> {
2715 if Self::can_cast(syntax.kind()) {
2716 Some(Self { syntax })
2721 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2723 impl AstNode for RecordPatFieldList {
2724 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD_LIST }
2725 fn cast(syntax: SyntaxNode) -> Option<Self> {
2726 if Self::can_cast(syntax.kind()) {
2727 Some(Self { syntax })
2732 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2734 impl AstNode for RecordPatField {
2735 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD }
2736 fn cast(syntax: SyntaxNode) -> Option<Self> {
2737 if Self::can_cast(syntax.kind()) {
2738 Some(Self { syntax })
2743 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2745 impl From<TypeArg> for GenericArg {
2746 fn from(node: TypeArg) -> GenericArg { GenericArg::TypeArg(node) }
2748 impl From<AssocTypeArg> for GenericArg {
2749 fn from(node: AssocTypeArg) -> GenericArg { GenericArg::AssocTypeArg(node) }
2751 impl From<LifetimeArg> for GenericArg {
2752 fn from(node: LifetimeArg) -> GenericArg { GenericArg::LifetimeArg(node) }
2754 impl From<ConstArg> for GenericArg {
2755 fn from(node: ConstArg) -> GenericArg { GenericArg::ConstArg(node) }
2757 impl AstNode for GenericArg {
2758 fn can_cast(kind: SyntaxKind) -> bool {
2760 TYPE_ARG | ASSOC_TYPE_ARG | LIFETIME_ARG | CONST_ARG => true,
2764 fn cast(syntax: SyntaxNode) -> Option<Self> {
2765 let res = match syntax.kind() {
2766 TYPE_ARG => GenericArg::TypeArg(TypeArg { syntax }),
2767 ASSOC_TYPE_ARG => GenericArg::AssocTypeArg(AssocTypeArg { syntax }),
2768 LIFETIME_ARG => GenericArg::LifetimeArg(LifetimeArg { syntax }),
2769 CONST_ARG => GenericArg::ConstArg(ConstArg { syntax }),
2774 fn syntax(&self) -> &SyntaxNode {
2776 GenericArg::TypeArg(it) => &it.syntax,
2777 GenericArg::AssocTypeArg(it) => &it.syntax,
2778 GenericArg::LifetimeArg(it) => &it.syntax,
2779 GenericArg::ConstArg(it) => &it.syntax,
2783 impl From<ArrayType> for Type {
2784 fn from(node: ArrayType) -> Type { Type::ArrayType(node) }
2786 impl From<DynTraitType> for Type {
2787 fn from(node: DynTraitType) -> Type { Type::DynTraitType(node) }
2789 impl From<FnPtrType> for Type {
2790 fn from(node: FnPtrType) -> Type { Type::FnPtrType(node) }
2792 impl From<ForType> for Type {
2793 fn from(node: ForType) -> Type { Type::ForType(node) }
2795 impl From<ImplTraitType> for Type {
2796 fn from(node: ImplTraitType) -> Type { Type::ImplTraitType(node) }
2798 impl From<InferType> for Type {
2799 fn from(node: InferType) -> Type { Type::InferType(node) }
2801 impl From<NeverType> for Type {
2802 fn from(node: NeverType) -> Type { Type::NeverType(node) }
2804 impl From<ParenType> for Type {
2805 fn from(node: ParenType) -> Type { Type::ParenType(node) }
2807 impl From<PathType> for Type {
2808 fn from(node: PathType) -> Type { Type::PathType(node) }
2810 impl From<PtrType> for Type {
2811 fn from(node: PtrType) -> Type { Type::PtrType(node) }
2813 impl From<RefType> for Type {
2814 fn from(node: RefType) -> Type { Type::RefType(node) }
2816 impl From<SliceType> for Type {
2817 fn from(node: SliceType) -> Type { Type::SliceType(node) }
2819 impl From<TupleType> for Type {
2820 fn from(node: TupleType) -> Type { Type::TupleType(node) }
2822 impl AstNode for Type {
2823 fn can_cast(kind: SyntaxKind) -> bool {
2825 ARRAY_TYPE | DYN_TRAIT_TYPE | FN_PTR_TYPE | FOR_TYPE | IMPL_TRAIT_TYPE | INFER_TYPE
2826 | NEVER_TYPE | PAREN_TYPE | PATH_TYPE | PTR_TYPE | REF_TYPE | SLICE_TYPE
2827 | TUPLE_TYPE => true,
2831 fn cast(syntax: SyntaxNode) -> Option<Self> {
2832 let res = match syntax.kind() {
2833 ARRAY_TYPE => Type::ArrayType(ArrayType { syntax }),
2834 DYN_TRAIT_TYPE => Type::DynTraitType(DynTraitType { syntax }),
2835 FN_PTR_TYPE => Type::FnPtrType(FnPtrType { syntax }),
2836 FOR_TYPE => Type::ForType(ForType { syntax }),
2837 IMPL_TRAIT_TYPE => Type::ImplTraitType(ImplTraitType { syntax }),
2838 INFER_TYPE => Type::InferType(InferType { syntax }),
2839 NEVER_TYPE => Type::NeverType(NeverType { syntax }),
2840 PAREN_TYPE => Type::ParenType(ParenType { syntax }),
2841 PATH_TYPE => Type::PathType(PathType { syntax }),
2842 PTR_TYPE => Type::PtrType(PtrType { syntax }),
2843 REF_TYPE => Type::RefType(RefType { syntax }),
2844 SLICE_TYPE => Type::SliceType(SliceType { syntax }),
2845 TUPLE_TYPE => Type::TupleType(TupleType { syntax }),
2850 fn syntax(&self) -> &SyntaxNode {
2852 Type::ArrayType(it) => &it.syntax,
2853 Type::DynTraitType(it) => &it.syntax,
2854 Type::FnPtrType(it) => &it.syntax,
2855 Type::ForType(it) => &it.syntax,
2856 Type::ImplTraitType(it) => &it.syntax,
2857 Type::InferType(it) => &it.syntax,
2858 Type::NeverType(it) => &it.syntax,
2859 Type::ParenType(it) => &it.syntax,
2860 Type::PathType(it) => &it.syntax,
2861 Type::PtrType(it) => &it.syntax,
2862 Type::RefType(it) => &it.syntax,
2863 Type::SliceType(it) => &it.syntax,
2864 Type::TupleType(it) => &it.syntax,
2868 impl From<ArrayExpr> for Expr {
2869 fn from(node: ArrayExpr) -> Expr { Expr::ArrayExpr(node) }
2871 impl From<AwaitExpr> for Expr {
2872 fn from(node: AwaitExpr) -> Expr { Expr::AwaitExpr(node) }
2874 impl From<BinExpr> for Expr {
2875 fn from(node: BinExpr) -> Expr { Expr::BinExpr(node) }
2877 impl From<BlockExpr> for Expr {
2878 fn from(node: BlockExpr) -> Expr { Expr::BlockExpr(node) }
2880 impl From<BoxExpr> for Expr {
2881 fn from(node: BoxExpr) -> Expr { Expr::BoxExpr(node) }
2883 impl From<BreakExpr> for Expr {
2884 fn from(node: BreakExpr) -> Expr { Expr::BreakExpr(node) }
2886 impl From<CallExpr> for Expr {
2887 fn from(node: CallExpr) -> Expr { Expr::CallExpr(node) }
2889 impl From<CastExpr> for Expr {
2890 fn from(node: CastExpr) -> Expr { Expr::CastExpr(node) }
2892 impl From<ClosureExpr> for Expr {
2893 fn from(node: ClosureExpr) -> Expr { Expr::ClosureExpr(node) }
2895 impl From<ContinueExpr> for Expr {
2896 fn from(node: ContinueExpr) -> Expr { Expr::ContinueExpr(node) }
2898 impl From<EffectExpr> for Expr {
2899 fn from(node: EffectExpr) -> Expr { Expr::EffectExpr(node) }
2901 impl From<FieldExpr> for Expr {
2902 fn from(node: FieldExpr) -> Expr { Expr::FieldExpr(node) }
2904 impl From<ForExpr> for Expr {
2905 fn from(node: ForExpr) -> Expr { Expr::ForExpr(node) }
2907 impl From<IfExpr> for Expr {
2908 fn from(node: IfExpr) -> Expr { Expr::IfExpr(node) }
2910 impl From<IndexExpr> for Expr {
2911 fn from(node: IndexExpr) -> Expr { Expr::IndexExpr(node) }
2913 impl From<Literal> for Expr {
2914 fn from(node: Literal) -> Expr { Expr::Literal(node) }
2916 impl From<LoopExpr> for Expr {
2917 fn from(node: LoopExpr) -> Expr { Expr::LoopExpr(node) }
2919 impl From<MacroCall> for Expr {
2920 fn from(node: MacroCall) -> Expr { Expr::MacroCall(node) }
2922 impl From<MatchExpr> for Expr {
2923 fn from(node: MatchExpr) -> Expr { Expr::MatchExpr(node) }
2925 impl From<MethodCallExpr> for Expr {
2926 fn from(node: MethodCallExpr) -> Expr { Expr::MethodCallExpr(node) }
2928 impl From<ParenExpr> for Expr {
2929 fn from(node: ParenExpr) -> Expr { Expr::ParenExpr(node) }
2931 impl From<PathExpr> for Expr {
2932 fn from(node: PathExpr) -> Expr { Expr::PathExpr(node) }
2934 impl From<PrefixExpr> for Expr {
2935 fn from(node: PrefixExpr) -> Expr { Expr::PrefixExpr(node) }
2937 impl From<RangeExpr> for Expr {
2938 fn from(node: RangeExpr) -> Expr { Expr::RangeExpr(node) }
2940 impl From<RecordExpr> for Expr {
2941 fn from(node: RecordExpr) -> Expr { Expr::RecordExpr(node) }
2943 impl From<RefExpr> for Expr {
2944 fn from(node: RefExpr) -> Expr { Expr::RefExpr(node) }
2946 impl From<ReturnExpr> for Expr {
2947 fn from(node: ReturnExpr) -> Expr { Expr::ReturnExpr(node) }
2949 impl From<TryExpr> for Expr {
2950 fn from(node: TryExpr) -> Expr { Expr::TryExpr(node) }
2952 impl From<TupleExpr> for Expr {
2953 fn from(node: TupleExpr) -> Expr { Expr::TupleExpr(node) }
2955 impl From<WhileExpr> for Expr {
2956 fn from(node: WhileExpr) -> Expr { Expr::WhileExpr(node) }
2958 impl AstNode for Expr {
2959 fn can_cast(kind: SyntaxKind) -> bool {
2961 ARRAY_EXPR | AWAIT_EXPR | BIN_EXPR | BLOCK_EXPR | BOX_EXPR | BREAK_EXPR | CALL_EXPR
2962 | CAST_EXPR | CLOSURE_EXPR | CONTINUE_EXPR | EFFECT_EXPR | FIELD_EXPR | FOR_EXPR
2963 | IF_EXPR | INDEX_EXPR | LITERAL | LOOP_EXPR | MACRO_CALL | MATCH_EXPR
2964 | METHOD_CALL_EXPR | PAREN_EXPR | PATH_EXPR | PREFIX_EXPR | RANGE_EXPR
2965 | RECORD_EXPR | REF_EXPR | RETURN_EXPR | TRY_EXPR | TUPLE_EXPR | WHILE_EXPR => true,
2969 fn cast(syntax: SyntaxNode) -> Option<Self> {
2970 let res = match syntax.kind() {
2971 ARRAY_EXPR => Expr::ArrayExpr(ArrayExpr { syntax }),
2972 AWAIT_EXPR => Expr::AwaitExpr(AwaitExpr { syntax }),
2973 BIN_EXPR => Expr::BinExpr(BinExpr { syntax }),
2974 BLOCK_EXPR => Expr::BlockExpr(BlockExpr { syntax }),
2975 BOX_EXPR => Expr::BoxExpr(BoxExpr { syntax }),
2976 BREAK_EXPR => Expr::BreakExpr(BreakExpr { syntax }),
2977 CALL_EXPR => Expr::CallExpr(CallExpr { syntax }),
2978 CAST_EXPR => Expr::CastExpr(CastExpr { syntax }),
2979 CLOSURE_EXPR => Expr::ClosureExpr(ClosureExpr { syntax }),
2980 CONTINUE_EXPR => Expr::ContinueExpr(ContinueExpr { syntax }),
2981 EFFECT_EXPR => Expr::EffectExpr(EffectExpr { syntax }),
2982 FIELD_EXPR => Expr::FieldExpr(FieldExpr { syntax }),
2983 FOR_EXPR => Expr::ForExpr(ForExpr { syntax }),
2984 IF_EXPR => Expr::IfExpr(IfExpr { syntax }),
2985 INDEX_EXPR => Expr::IndexExpr(IndexExpr { syntax }),
2986 LITERAL => Expr::Literal(Literal { syntax }),
2987 LOOP_EXPR => Expr::LoopExpr(LoopExpr { syntax }),
2988 MACRO_CALL => Expr::MacroCall(MacroCall { syntax }),
2989 MATCH_EXPR => Expr::MatchExpr(MatchExpr { syntax }),
2990 METHOD_CALL_EXPR => Expr::MethodCallExpr(MethodCallExpr { syntax }),
2991 PAREN_EXPR => Expr::ParenExpr(ParenExpr { syntax }),
2992 PATH_EXPR => Expr::PathExpr(PathExpr { syntax }),
2993 PREFIX_EXPR => Expr::PrefixExpr(PrefixExpr { syntax }),
2994 RANGE_EXPR => Expr::RangeExpr(RangeExpr { syntax }),
2995 RECORD_EXPR => Expr::RecordExpr(RecordExpr { syntax }),
2996 REF_EXPR => Expr::RefExpr(RefExpr { syntax }),
2997 RETURN_EXPR => Expr::ReturnExpr(ReturnExpr { syntax }),
2998 TRY_EXPR => Expr::TryExpr(TryExpr { syntax }),
2999 TUPLE_EXPR => Expr::TupleExpr(TupleExpr { syntax }),
3000 WHILE_EXPR => Expr::WhileExpr(WhileExpr { syntax }),
3005 fn syntax(&self) -> &SyntaxNode {
3007 Expr::ArrayExpr(it) => &it.syntax,
3008 Expr::AwaitExpr(it) => &it.syntax,
3009 Expr::BinExpr(it) => &it.syntax,
3010 Expr::BlockExpr(it) => &it.syntax,
3011 Expr::BoxExpr(it) => &it.syntax,
3012 Expr::BreakExpr(it) => &it.syntax,
3013 Expr::CallExpr(it) => &it.syntax,
3014 Expr::CastExpr(it) => &it.syntax,
3015 Expr::ClosureExpr(it) => &it.syntax,
3016 Expr::ContinueExpr(it) => &it.syntax,
3017 Expr::EffectExpr(it) => &it.syntax,
3018 Expr::FieldExpr(it) => &it.syntax,
3019 Expr::ForExpr(it) => &it.syntax,
3020 Expr::IfExpr(it) => &it.syntax,
3021 Expr::IndexExpr(it) => &it.syntax,
3022 Expr::Literal(it) => &it.syntax,
3023 Expr::LoopExpr(it) => &it.syntax,
3024 Expr::MacroCall(it) => &it.syntax,
3025 Expr::MatchExpr(it) => &it.syntax,
3026 Expr::MethodCallExpr(it) => &it.syntax,
3027 Expr::ParenExpr(it) => &it.syntax,
3028 Expr::PathExpr(it) => &it.syntax,
3029 Expr::PrefixExpr(it) => &it.syntax,
3030 Expr::RangeExpr(it) => &it.syntax,
3031 Expr::RecordExpr(it) => &it.syntax,
3032 Expr::RefExpr(it) => &it.syntax,
3033 Expr::ReturnExpr(it) => &it.syntax,
3034 Expr::TryExpr(it) => &it.syntax,
3035 Expr::TupleExpr(it) => &it.syntax,
3036 Expr::WhileExpr(it) => &it.syntax,
3040 impl From<Const> for Item {
3041 fn from(node: Const) -> Item { Item::Const(node) }
3043 impl From<Enum> for Item {
3044 fn from(node: Enum) -> Item { Item::Enum(node) }
3046 impl From<ExternBlock> for Item {
3047 fn from(node: ExternBlock) -> Item { Item::ExternBlock(node) }
3049 impl From<ExternCrate> for Item {
3050 fn from(node: ExternCrate) -> Item { Item::ExternCrate(node) }
3052 impl From<Fn> for Item {
3053 fn from(node: Fn) -> Item { Item::Fn(node) }
3055 impl From<Impl> for Item {
3056 fn from(node: Impl) -> Item { Item::Impl(node) }
3058 impl From<MacroCall> for Item {
3059 fn from(node: MacroCall) -> Item { Item::MacroCall(node) }
3061 impl From<Module> for Item {
3062 fn from(node: Module) -> Item { Item::Module(node) }
3064 impl From<Static> for Item {
3065 fn from(node: Static) -> Item { Item::Static(node) }
3067 impl From<Struct> for Item {
3068 fn from(node: Struct) -> Item { Item::Struct(node) }
3070 impl From<Trait> for Item {
3071 fn from(node: Trait) -> Item { Item::Trait(node) }
3073 impl From<TypeAlias> for Item {
3074 fn from(node: TypeAlias) -> Item { Item::TypeAlias(node) }
3076 impl From<Union> for Item {
3077 fn from(node: Union) -> Item { Item::Union(node) }
3079 impl From<Use> for Item {
3080 fn from(node: Use) -> Item { Item::Use(node) }
3082 impl AstNode for Item {
3083 fn can_cast(kind: SyntaxKind) -> bool {
3085 CONST | ENUM | EXTERN_BLOCK | EXTERN_CRATE | FN | IMPL | MACRO_CALL | MODULE
3086 | STATIC | STRUCT | TRAIT | TYPE_ALIAS | UNION | USE => true,
3090 fn cast(syntax: SyntaxNode) -> Option<Self> {
3091 let res = match syntax.kind() {
3092 CONST => Item::Const(Const { syntax }),
3093 ENUM => Item::Enum(Enum { syntax }),
3094 EXTERN_BLOCK => Item::ExternBlock(ExternBlock { syntax }),
3095 EXTERN_CRATE => Item::ExternCrate(ExternCrate { syntax }),
3096 FN => Item::Fn(Fn { syntax }),
3097 IMPL => Item::Impl(Impl { syntax }),
3098 MACRO_CALL => Item::MacroCall(MacroCall { syntax }),
3099 MODULE => Item::Module(Module { syntax }),
3100 STATIC => Item::Static(Static { syntax }),
3101 STRUCT => Item::Struct(Struct { syntax }),
3102 TRAIT => Item::Trait(Trait { syntax }),
3103 TYPE_ALIAS => Item::TypeAlias(TypeAlias { syntax }),
3104 UNION => Item::Union(Union { syntax }),
3105 USE => Item::Use(Use { syntax }),
3110 fn syntax(&self) -> &SyntaxNode {
3112 Item::Const(it) => &it.syntax,
3113 Item::Enum(it) => &it.syntax,
3114 Item::ExternBlock(it) => &it.syntax,
3115 Item::ExternCrate(it) => &it.syntax,
3116 Item::Fn(it) => &it.syntax,
3117 Item::Impl(it) => &it.syntax,
3118 Item::MacroCall(it) => &it.syntax,
3119 Item::Module(it) => &it.syntax,
3120 Item::Static(it) => &it.syntax,
3121 Item::Struct(it) => &it.syntax,
3122 Item::Trait(it) => &it.syntax,
3123 Item::TypeAlias(it) => &it.syntax,
3124 Item::Union(it) => &it.syntax,
3125 Item::Use(it) => &it.syntax,
3129 impl From<ExprStmt> for Stmt {
3130 fn from(node: ExprStmt) -> Stmt { Stmt::ExprStmt(node) }
3132 impl From<Item> for Stmt {
3133 fn from(node: Item) -> Stmt { Stmt::Item(node) }
3135 impl From<LetStmt> for Stmt {
3136 fn from(node: LetStmt) -> Stmt { Stmt::LetStmt(node) }
3138 impl From<IdentPat> for Pat {
3139 fn from(node: IdentPat) -> Pat { Pat::IdentPat(node) }
3141 impl From<BoxPat> for Pat {
3142 fn from(node: BoxPat) -> Pat { Pat::BoxPat(node) }
3144 impl From<RestPat> for Pat {
3145 fn from(node: RestPat) -> Pat { Pat::RestPat(node) }
3147 impl From<LiteralPat> for Pat {
3148 fn from(node: LiteralPat) -> Pat { Pat::LiteralPat(node) }
3150 impl From<MacroPat> for Pat {
3151 fn from(node: MacroPat) -> Pat { Pat::MacroPat(node) }
3153 impl From<OrPat> for Pat {
3154 fn from(node: OrPat) -> Pat { Pat::OrPat(node) }
3156 impl From<ParenPat> for Pat {
3157 fn from(node: ParenPat) -> Pat { Pat::ParenPat(node) }
3159 impl From<PathPat> for Pat {
3160 fn from(node: PathPat) -> Pat { Pat::PathPat(node) }
3162 impl From<WildcardPat> for Pat {
3163 fn from(node: WildcardPat) -> Pat { Pat::WildcardPat(node) }
3165 impl From<RangePat> for Pat {
3166 fn from(node: RangePat) -> Pat { Pat::RangePat(node) }
3168 impl From<RecordPat> for Pat {
3169 fn from(node: RecordPat) -> Pat { Pat::RecordPat(node) }
3171 impl From<RefPat> for Pat {
3172 fn from(node: RefPat) -> Pat { Pat::RefPat(node) }
3174 impl From<SlicePat> for Pat {
3175 fn from(node: SlicePat) -> Pat { Pat::SlicePat(node) }
3177 impl From<TuplePat> for Pat {
3178 fn from(node: TuplePat) -> Pat { Pat::TuplePat(node) }
3180 impl From<TupleStructPat> for Pat {
3181 fn from(node: TupleStructPat) -> Pat { Pat::TupleStructPat(node) }
3183 impl AstNode for Pat {
3184 fn can_cast(kind: SyntaxKind) -> bool {
3186 IDENT_PAT | BOX_PAT | REST_PAT | LITERAL_PAT | MACRO_PAT | OR_PAT | PAREN_PAT
3187 | PATH_PAT | WILDCARD_PAT | RANGE_PAT | RECORD_PAT | REF_PAT | SLICE_PAT
3188 | TUPLE_PAT | TUPLE_STRUCT_PAT => true,
3192 fn cast(syntax: SyntaxNode) -> Option<Self> {
3193 let res = match syntax.kind() {
3194 IDENT_PAT => Pat::IdentPat(IdentPat { syntax }),
3195 BOX_PAT => Pat::BoxPat(BoxPat { syntax }),
3196 REST_PAT => Pat::RestPat(RestPat { syntax }),
3197 LITERAL_PAT => Pat::LiteralPat(LiteralPat { syntax }),
3198 MACRO_PAT => Pat::MacroPat(MacroPat { syntax }),
3199 OR_PAT => Pat::OrPat(OrPat { syntax }),
3200 PAREN_PAT => Pat::ParenPat(ParenPat { syntax }),
3201 PATH_PAT => Pat::PathPat(PathPat { syntax }),
3202 WILDCARD_PAT => Pat::WildcardPat(WildcardPat { syntax }),
3203 RANGE_PAT => Pat::RangePat(RangePat { syntax }),
3204 RECORD_PAT => Pat::RecordPat(RecordPat { syntax }),
3205 REF_PAT => Pat::RefPat(RefPat { syntax }),
3206 SLICE_PAT => Pat::SlicePat(SlicePat { syntax }),
3207 TUPLE_PAT => Pat::TuplePat(TuplePat { syntax }),
3208 TUPLE_STRUCT_PAT => Pat::TupleStructPat(TupleStructPat { syntax }),
3213 fn syntax(&self) -> &SyntaxNode {
3215 Pat::IdentPat(it) => &it.syntax,
3216 Pat::BoxPat(it) => &it.syntax,
3217 Pat::RestPat(it) => &it.syntax,
3218 Pat::LiteralPat(it) => &it.syntax,
3219 Pat::MacroPat(it) => &it.syntax,
3220 Pat::OrPat(it) => &it.syntax,
3221 Pat::ParenPat(it) => &it.syntax,
3222 Pat::PathPat(it) => &it.syntax,
3223 Pat::WildcardPat(it) => &it.syntax,
3224 Pat::RangePat(it) => &it.syntax,
3225 Pat::RecordPat(it) => &it.syntax,
3226 Pat::RefPat(it) => &it.syntax,
3227 Pat::SlicePat(it) => &it.syntax,
3228 Pat::TuplePat(it) => &it.syntax,
3229 Pat::TupleStructPat(it) => &it.syntax,
3233 impl From<RecordFieldList> for FieldList {
3234 fn from(node: RecordFieldList) -> FieldList { FieldList::RecordFieldList(node) }
3236 impl From<TupleFieldList> for FieldList {
3237 fn from(node: TupleFieldList) -> FieldList { FieldList::TupleFieldList(node) }
3239 impl AstNode for FieldList {
3240 fn can_cast(kind: SyntaxKind) -> bool {
3242 RECORD_FIELD_LIST | TUPLE_FIELD_LIST => true,
3246 fn cast(syntax: SyntaxNode) -> Option<Self> {
3247 let res = match syntax.kind() {
3248 RECORD_FIELD_LIST => FieldList::RecordFieldList(RecordFieldList { syntax }),
3249 TUPLE_FIELD_LIST => FieldList::TupleFieldList(TupleFieldList { syntax }),
3254 fn syntax(&self) -> &SyntaxNode {
3256 FieldList::RecordFieldList(it) => &it.syntax,
3257 FieldList::TupleFieldList(it) => &it.syntax,
3261 impl From<Enum> for AdtDef {
3262 fn from(node: Enum) -> AdtDef { AdtDef::Enum(node) }
3264 impl From<Struct> for AdtDef {
3265 fn from(node: Struct) -> AdtDef { AdtDef::Struct(node) }
3267 impl From<Union> for AdtDef {
3268 fn from(node: Union) -> AdtDef { AdtDef::Union(node) }
3270 impl AstNode for AdtDef {
3271 fn can_cast(kind: SyntaxKind) -> bool {
3273 ENUM | STRUCT | UNION => true,
3277 fn cast(syntax: SyntaxNode) -> Option<Self> {
3278 let res = match syntax.kind() {
3279 ENUM => AdtDef::Enum(Enum { syntax }),
3280 STRUCT => AdtDef::Struct(Struct { syntax }),
3281 UNION => AdtDef::Union(Union { syntax }),
3286 fn syntax(&self) -> &SyntaxNode {
3288 AdtDef::Enum(it) => &it.syntax,
3289 AdtDef::Struct(it) => &it.syntax,
3290 AdtDef::Union(it) => &it.syntax,
3294 impl From<Const> for AssocItem {
3295 fn from(node: Const) -> AssocItem { AssocItem::Const(node) }
3297 impl From<Fn> for AssocItem {
3298 fn from(node: Fn) -> AssocItem { AssocItem::Fn(node) }
3300 impl From<MacroCall> for AssocItem {
3301 fn from(node: MacroCall) -> AssocItem { AssocItem::MacroCall(node) }
3303 impl From<TypeAlias> for AssocItem {
3304 fn from(node: TypeAlias) -> AssocItem { AssocItem::TypeAlias(node) }
3306 impl AstNode for AssocItem {
3307 fn can_cast(kind: SyntaxKind) -> bool {
3309 CONST | FN | MACRO_CALL | TYPE_ALIAS => true,
3313 fn cast(syntax: SyntaxNode) -> Option<Self> {
3314 let res = match syntax.kind() {
3315 CONST => AssocItem::Const(Const { syntax }),
3316 FN => AssocItem::Fn(Fn { syntax }),
3317 MACRO_CALL => AssocItem::MacroCall(MacroCall { syntax }),
3318 TYPE_ALIAS => AssocItem::TypeAlias(TypeAlias { syntax }),
3323 fn syntax(&self) -> &SyntaxNode {
3325 AssocItem::Const(it) => &it.syntax,
3326 AssocItem::Fn(it) => &it.syntax,
3327 AssocItem::MacroCall(it) => &it.syntax,
3328 AssocItem::TypeAlias(it) => &it.syntax,
3332 impl From<Fn> for ExternItem {
3333 fn from(node: Fn) -> ExternItem { ExternItem::Fn(node) }
3335 impl From<MacroCall> for ExternItem {
3336 fn from(node: MacroCall) -> ExternItem { ExternItem::MacroCall(node) }
3338 impl From<Static> for ExternItem {
3339 fn from(node: Static) -> ExternItem { ExternItem::Static(node) }
3341 impl AstNode for ExternItem {
3342 fn can_cast(kind: SyntaxKind) -> bool {
3344 FN | MACRO_CALL | STATIC => true,
3348 fn cast(syntax: SyntaxNode) -> Option<Self> {
3349 let res = match syntax.kind() {
3350 FN => ExternItem::Fn(Fn { syntax }),
3351 MACRO_CALL => ExternItem::MacroCall(MacroCall { syntax }),
3352 STATIC => ExternItem::Static(Static { syntax }),
3357 fn syntax(&self) -> &SyntaxNode {
3359 ExternItem::Fn(it) => &it.syntax,
3360 ExternItem::MacroCall(it) => &it.syntax,
3361 ExternItem::Static(it) => &it.syntax,
3365 impl From<ConstParam> for GenericParam {
3366 fn from(node: ConstParam) -> GenericParam { GenericParam::ConstParam(node) }
3368 impl From<LifetimeParam> for GenericParam {
3369 fn from(node: LifetimeParam) -> GenericParam { GenericParam::LifetimeParam(node) }
3371 impl From<TypeParam> for GenericParam {
3372 fn from(node: TypeParam) -> GenericParam { GenericParam::TypeParam(node) }
3374 impl AstNode for GenericParam {
3375 fn can_cast(kind: SyntaxKind) -> bool {
3377 CONST_PARAM | LIFETIME_PARAM | TYPE_PARAM => true,
3381 fn cast(syntax: SyntaxNode) -> Option<Self> {
3382 let res = match syntax.kind() {
3383 CONST_PARAM => GenericParam::ConstParam(ConstParam { syntax }),
3384 LIFETIME_PARAM => GenericParam::LifetimeParam(LifetimeParam { syntax }),
3385 TYPE_PARAM => GenericParam::TypeParam(TypeParam { syntax }),
3390 fn syntax(&self) -> &SyntaxNode {
3392 GenericParam::ConstParam(it) => &it.syntax,
3393 GenericParam::LifetimeParam(it) => &it.syntax,
3394 GenericParam::TypeParam(it) => &it.syntax,
3398 impl std::fmt::Display for GenericArg {
3399 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3400 std::fmt::Display::fmt(self.syntax(), f)
3403 impl std::fmt::Display for Type {
3404 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3405 std::fmt::Display::fmt(self.syntax(), f)
3408 impl std::fmt::Display for Expr {
3409 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3410 std::fmt::Display::fmt(self.syntax(), f)
3413 impl std::fmt::Display for Item {
3414 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3415 std::fmt::Display::fmt(self.syntax(), f)
3418 impl std::fmt::Display for Stmt {
3419 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3420 std::fmt::Display::fmt(self.syntax(), f)
3423 impl std::fmt::Display for Pat {
3424 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3425 std::fmt::Display::fmt(self.syntax(), f)
3428 impl std::fmt::Display for FieldList {
3429 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3430 std::fmt::Display::fmt(self.syntax(), f)
3433 impl std::fmt::Display for AdtDef {
3434 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3435 std::fmt::Display::fmt(self.syntax(), f)
3438 impl std::fmt::Display for AssocItem {
3439 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3440 std::fmt::Display::fmt(self.syntax(), f)
3443 impl std::fmt::Display for ExternItem {
3444 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3445 std::fmt::Display::fmt(self.syntax(), f)
3448 impl std::fmt::Display for GenericParam {
3449 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3450 std::fmt::Display::fmt(self.syntax(), f)
3453 impl std::fmt::Display for Name {
3454 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3455 std::fmt::Display::fmt(self.syntax(), f)
3458 impl std::fmt::Display for NameRef {
3459 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3460 std::fmt::Display::fmt(self.syntax(), f)
3463 impl std::fmt::Display for Path {
3464 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3465 std::fmt::Display::fmt(self.syntax(), f)
3468 impl std::fmt::Display for PathSegment {
3469 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3470 std::fmt::Display::fmt(self.syntax(), f)
3473 impl std::fmt::Display for GenericArgList {
3474 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3475 std::fmt::Display::fmt(self.syntax(), f)
3478 impl std::fmt::Display for ParamList {
3479 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3480 std::fmt::Display::fmt(self.syntax(), f)
3483 impl std::fmt::Display for RetType {
3484 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3485 std::fmt::Display::fmt(self.syntax(), f)
3488 impl std::fmt::Display for PathType {
3489 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3490 std::fmt::Display::fmt(self.syntax(), f)
3493 impl std::fmt::Display for TypeArg {
3494 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3495 std::fmt::Display::fmt(self.syntax(), f)
3498 impl std::fmt::Display for AssocTypeArg {
3499 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3500 std::fmt::Display::fmt(self.syntax(), f)
3503 impl std::fmt::Display for LifetimeArg {
3504 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3505 std::fmt::Display::fmt(self.syntax(), f)
3508 impl std::fmt::Display for ConstArg {
3509 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3510 std::fmt::Display::fmt(self.syntax(), f)
3513 impl std::fmt::Display for TypeBoundList {
3514 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3515 std::fmt::Display::fmt(self.syntax(), f)
3518 impl std::fmt::Display for MacroCall {
3519 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3520 std::fmt::Display::fmt(self.syntax(), f)
3523 impl std::fmt::Display for Attr {
3524 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3525 std::fmt::Display::fmt(self.syntax(), f)
3528 impl std::fmt::Display for TokenTree {
3529 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3530 std::fmt::Display::fmt(self.syntax(), f)
3533 impl std::fmt::Display for MacroItems {
3534 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3535 std::fmt::Display::fmt(self.syntax(), f)
3538 impl std::fmt::Display for MacroStmts {
3539 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3540 std::fmt::Display::fmt(self.syntax(), f)
3543 impl std::fmt::Display for SourceFile {
3544 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3545 std::fmt::Display::fmt(self.syntax(), f)
3548 impl std::fmt::Display for Const {
3549 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3550 std::fmt::Display::fmt(self.syntax(), f)
3553 impl std::fmt::Display for Enum {
3554 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3555 std::fmt::Display::fmt(self.syntax(), f)
3558 impl std::fmt::Display for ExternBlock {
3559 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3560 std::fmt::Display::fmt(self.syntax(), f)
3563 impl std::fmt::Display for ExternCrate {
3564 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3565 std::fmt::Display::fmt(self.syntax(), f)
3568 impl std::fmt::Display for Fn {
3569 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3570 std::fmt::Display::fmt(self.syntax(), f)
3573 impl std::fmt::Display for Impl {
3574 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3575 std::fmt::Display::fmt(self.syntax(), f)
3578 impl std::fmt::Display for Module {
3579 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3580 std::fmt::Display::fmt(self.syntax(), f)
3583 impl std::fmt::Display for Static {
3584 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3585 std::fmt::Display::fmt(self.syntax(), f)
3588 impl std::fmt::Display for Struct {
3589 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3590 std::fmt::Display::fmt(self.syntax(), f)
3593 impl std::fmt::Display for Trait {
3594 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3595 std::fmt::Display::fmt(self.syntax(), f)
3598 impl std::fmt::Display for TypeAlias {
3599 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3600 std::fmt::Display::fmt(self.syntax(), f)
3603 impl std::fmt::Display for Union {
3604 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3605 std::fmt::Display::fmt(self.syntax(), f)
3608 impl std::fmt::Display for Use {
3609 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3610 std::fmt::Display::fmt(self.syntax(), f)
3613 impl std::fmt::Display for Visibility {
3614 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3615 std::fmt::Display::fmt(self.syntax(), f)
3618 impl std::fmt::Display for ItemList {
3619 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3620 std::fmt::Display::fmt(self.syntax(), f)
3623 impl std::fmt::Display for Rename {
3624 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3625 std::fmt::Display::fmt(self.syntax(), f)
3628 impl std::fmt::Display for UseTree {
3629 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3630 std::fmt::Display::fmt(self.syntax(), f)
3633 impl std::fmt::Display for UseTreeList {
3634 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3635 std::fmt::Display::fmt(self.syntax(), f)
3638 impl std::fmt::Display for Abi {
3639 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3640 std::fmt::Display::fmt(self.syntax(), f)
3643 impl std::fmt::Display for GenericParamList {
3644 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3645 std::fmt::Display::fmt(self.syntax(), f)
3648 impl std::fmt::Display for WhereClause {
3649 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3650 std::fmt::Display::fmt(self.syntax(), f)
3653 impl std::fmt::Display for BlockExpr {
3654 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3655 std::fmt::Display::fmt(self.syntax(), f)
3658 impl std::fmt::Display for SelfParam {
3659 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3660 std::fmt::Display::fmt(self.syntax(), f)
3663 impl std::fmt::Display for Param {
3664 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3665 std::fmt::Display::fmt(self.syntax(), f)
3668 impl std::fmt::Display for RecordFieldList {
3669 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3670 std::fmt::Display::fmt(self.syntax(), f)
3673 impl std::fmt::Display for TupleFieldList {
3674 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3675 std::fmt::Display::fmt(self.syntax(), f)
3678 impl std::fmt::Display for RecordField {
3679 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3680 std::fmt::Display::fmt(self.syntax(), f)
3683 impl std::fmt::Display for TupleField {
3684 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3685 std::fmt::Display::fmt(self.syntax(), f)
3688 impl std::fmt::Display for VariantList {
3689 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3690 std::fmt::Display::fmt(self.syntax(), f)
3693 impl std::fmt::Display for Variant {
3694 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3695 std::fmt::Display::fmt(self.syntax(), f)
3698 impl std::fmt::Display for AssocItemList {
3699 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3700 std::fmt::Display::fmt(self.syntax(), f)
3703 impl std::fmt::Display for ExternItemList {
3704 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3705 std::fmt::Display::fmt(self.syntax(), f)
3708 impl std::fmt::Display for ConstParam {
3709 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3710 std::fmt::Display::fmt(self.syntax(), f)
3713 impl std::fmt::Display for LifetimeParam {
3714 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3715 std::fmt::Display::fmt(self.syntax(), f)
3718 impl std::fmt::Display for TypeParam {
3719 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3720 std::fmt::Display::fmt(self.syntax(), f)
3723 impl std::fmt::Display for WherePred {
3724 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3725 std::fmt::Display::fmt(self.syntax(), f)
3728 impl std::fmt::Display for Literal {
3729 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3730 std::fmt::Display::fmt(self.syntax(), f)
3733 impl std::fmt::Display for ExprStmt {
3734 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3735 std::fmt::Display::fmt(self.syntax(), f)
3738 impl std::fmt::Display for LetStmt {
3739 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3740 std::fmt::Display::fmt(self.syntax(), f)
3743 impl std::fmt::Display for ArrayExpr {
3744 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3745 std::fmt::Display::fmt(self.syntax(), f)
3748 impl std::fmt::Display for AwaitExpr {
3749 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3750 std::fmt::Display::fmt(self.syntax(), f)
3753 impl std::fmt::Display for BinExpr {
3754 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3755 std::fmt::Display::fmt(self.syntax(), f)
3758 impl std::fmt::Display for BoxExpr {
3759 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3760 std::fmt::Display::fmt(self.syntax(), f)
3763 impl std::fmt::Display for BreakExpr {
3764 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3765 std::fmt::Display::fmt(self.syntax(), f)
3768 impl std::fmt::Display for CallExpr {
3769 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3770 std::fmt::Display::fmt(self.syntax(), f)
3773 impl std::fmt::Display for CastExpr {
3774 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3775 std::fmt::Display::fmt(self.syntax(), f)
3778 impl std::fmt::Display for ClosureExpr {
3779 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3780 std::fmt::Display::fmt(self.syntax(), f)
3783 impl std::fmt::Display for ContinueExpr {
3784 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3785 std::fmt::Display::fmt(self.syntax(), f)
3788 impl std::fmt::Display for EffectExpr {
3789 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3790 std::fmt::Display::fmt(self.syntax(), f)
3793 impl std::fmt::Display for FieldExpr {
3794 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3795 std::fmt::Display::fmt(self.syntax(), f)
3798 impl std::fmt::Display for ForExpr {
3799 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3800 std::fmt::Display::fmt(self.syntax(), f)
3803 impl std::fmt::Display for IfExpr {
3804 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3805 std::fmt::Display::fmt(self.syntax(), f)
3808 impl std::fmt::Display for IndexExpr {
3809 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3810 std::fmt::Display::fmt(self.syntax(), f)
3813 impl std::fmt::Display for LoopExpr {
3814 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3815 std::fmt::Display::fmt(self.syntax(), f)
3818 impl std::fmt::Display for MatchExpr {
3819 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3820 std::fmt::Display::fmt(self.syntax(), f)
3823 impl std::fmt::Display for MethodCallExpr {
3824 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3825 std::fmt::Display::fmt(self.syntax(), f)
3828 impl std::fmt::Display for ParenExpr {
3829 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3830 std::fmt::Display::fmt(self.syntax(), f)
3833 impl std::fmt::Display for PathExpr {
3834 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3835 std::fmt::Display::fmt(self.syntax(), f)
3838 impl std::fmt::Display for PrefixExpr {
3839 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3840 std::fmt::Display::fmt(self.syntax(), f)
3843 impl std::fmt::Display for RangeExpr {
3844 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3845 std::fmt::Display::fmt(self.syntax(), f)
3848 impl std::fmt::Display for RecordExpr {
3849 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3850 std::fmt::Display::fmt(self.syntax(), f)
3853 impl std::fmt::Display for RefExpr {
3854 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3855 std::fmt::Display::fmt(self.syntax(), f)
3858 impl std::fmt::Display for ReturnExpr {
3859 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3860 std::fmt::Display::fmt(self.syntax(), f)
3863 impl std::fmt::Display for TryExpr {
3864 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3865 std::fmt::Display::fmt(self.syntax(), f)
3868 impl std::fmt::Display for TupleExpr {
3869 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3870 std::fmt::Display::fmt(self.syntax(), f)
3873 impl std::fmt::Display for WhileExpr {
3874 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3875 std::fmt::Display::fmt(self.syntax(), f)
3878 impl std::fmt::Display for Label {
3879 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3880 std::fmt::Display::fmt(self.syntax(), f)
3883 impl std::fmt::Display for RecordExprFieldList {
3884 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3885 std::fmt::Display::fmt(self.syntax(), f)
3888 impl std::fmt::Display for RecordExprField {
3889 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3890 std::fmt::Display::fmt(self.syntax(), f)
3893 impl std::fmt::Display for ArgList {
3894 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3895 std::fmt::Display::fmt(self.syntax(), f)
3898 impl std::fmt::Display for Condition {
3899 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3900 std::fmt::Display::fmt(self.syntax(), f)
3903 impl std::fmt::Display for MatchArmList {
3904 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3905 std::fmt::Display::fmt(self.syntax(), f)
3908 impl std::fmt::Display for MatchArm {
3909 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3910 std::fmt::Display::fmt(self.syntax(), f)
3913 impl std::fmt::Display for MatchGuard {
3914 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3915 std::fmt::Display::fmt(self.syntax(), f)
3918 impl std::fmt::Display for ArrayType {
3919 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3920 std::fmt::Display::fmt(self.syntax(), f)
3923 impl std::fmt::Display for DynTraitType {
3924 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3925 std::fmt::Display::fmt(self.syntax(), f)
3928 impl std::fmt::Display for FnPtrType {
3929 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3930 std::fmt::Display::fmt(self.syntax(), f)
3933 impl std::fmt::Display for ForType {
3934 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3935 std::fmt::Display::fmt(self.syntax(), f)
3938 impl std::fmt::Display for ImplTraitType {
3939 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3940 std::fmt::Display::fmt(self.syntax(), f)
3943 impl std::fmt::Display for InferType {
3944 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3945 std::fmt::Display::fmt(self.syntax(), f)
3948 impl std::fmt::Display for NeverType {
3949 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3950 std::fmt::Display::fmt(self.syntax(), f)
3953 impl std::fmt::Display for ParenType {
3954 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3955 std::fmt::Display::fmt(self.syntax(), f)
3958 impl std::fmt::Display for PtrType {
3959 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3960 std::fmt::Display::fmt(self.syntax(), f)
3963 impl std::fmt::Display for RefType {
3964 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3965 std::fmt::Display::fmt(self.syntax(), f)
3968 impl std::fmt::Display for SliceType {
3969 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3970 std::fmt::Display::fmt(self.syntax(), f)
3973 impl std::fmt::Display for TupleType {
3974 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3975 std::fmt::Display::fmt(self.syntax(), f)
3978 impl std::fmt::Display for TypeBound {
3979 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3980 std::fmt::Display::fmt(self.syntax(), f)
3983 impl std::fmt::Display for IdentPat {
3984 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3985 std::fmt::Display::fmt(self.syntax(), f)
3988 impl std::fmt::Display for BoxPat {
3989 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3990 std::fmt::Display::fmt(self.syntax(), f)
3993 impl std::fmt::Display for RestPat {
3994 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3995 std::fmt::Display::fmt(self.syntax(), f)
3998 impl std::fmt::Display for LiteralPat {
3999 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4000 std::fmt::Display::fmt(self.syntax(), f)
4003 impl std::fmt::Display for MacroPat {
4004 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4005 std::fmt::Display::fmt(self.syntax(), f)
4008 impl std::fmt::Display for OrPat {
4009 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4010 std::fmt::Display::fmt(self.syntax(), f)
4013 impl std::fmt::Display for ParenPat {
4014 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4015 std::fmt::Display::fmt(self.syntax(), f)
4018 impl std::fmt::Display for PathPat {
4019 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4020 std::fmt::Display::fmt(self.syntax(), f)
4023 impl std::fmt::Display for WildcardPat {
4024 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4025 std::fmt::Display::fmt(self.syntax(), f)
4028 impl std::fmt::Display for RangePat {
4029 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4030 std::fmt::Display::fmt(self.syntax(), f)
4033 impl std::fmt::Display for RecordPat {
4034 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4035 std::fmt::Display::fmt(self.syntax(), f)
4038 impl std::fmt::Display for RefPat {
4039 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4040 std::fmt::Display::fmt(self.syntax(), f)
4043 impl std::fmt::Display for SlicePat {
4044 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4045 std::fmt::Display::fmt(self.syntax(), f)
4048 impl std::fmt::Display for TuplePat {
4049 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4050 std::fmt::Display::fmt(self.syntax(), f)
4053 impl std::fmt::Display for TupleStructPat {
4054 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4055 std::fmt::Display::fmt(self.syntax(), f)
4058 impl std::fmt::Display for RecordPatFieldList {
4059 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4060 std::fmt::Display::fmt(self.syntax(), f)
4063 impl std::fmt::Display for RecordPatField {
4064 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4065 std::fmt::Display::fmt(self.syntax(), f)