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