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