aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_syntax/src/ast
diff options
context:
space:
mode:
authorBenjamin Coenen <[email protected]>2020-04-09 17:37:34 +0100
committerBenjamin Coenen <[email protected]>2020-04-09 18:12:50 +0100
commitc1317d692321ba5ba8f138067ebefbb9559d098d (patch)
treee29a44577e4d2cf55b6f53e3428abea43bbd33d7 /crates/ra_syntax/src/ast
parentfc70cf9458c5234decafdd52b9aced790ac43d7a (diff)
parent30f0ad159a0f260f54356385de63c171722adb72 (diff)
feat: add support for feature attributes in struct literal
Signed-off-by: Benjamin Coenen <[email protected]>
Diffstat (limited to 'crates/ra_syntax/src/ast')
-rw-r--r--crates/ra_syntax/src/ast/edit.rs26
-rw-r--r--crates/ra_syntax/src/ast/expr_extensions.rs4
-rw-r--r--crates/ra_syntax/src/ast/extensions.rs147
-rw-r--r--crates/ra_syntax/src/ast/generated.rs7881
-rw-r--r--crates/ra_syntax/src/ast/generated/nodes.rs4177
-rw-r--r--crates/ra_syntax/src/ast/generated/tokens.rs2808
-rw-r--r--crates/ra_syntax/src/ast/traits.rs10
7 files changed, 7089 insertions, 7964 deletions
diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs
index b69cae234..d79310995 100644
--- a/crates/ra_syntax/src/ast/edit.rs
+++ b/crates/ra_syntax/src/ast/edit.rs
@@ -99,7 +99,7 @@ impl ast::ItemList {
99 None => match self.l_curly() { 99 None => match self.l_curly() {
100 Some(it) => ( 100 Some(it) => (
101 " ".to_string() + &leading_indent(self.syntax()).unwrap_or_default(), 101 " ".to_string() + &leading_indent(self.syntax()).unwrap_or_default(),
102 InsertPosition::After(it), 102 InsertPosition::After(it.syntax().clone().into()),
103 ), 103 ),
104 None => return self.clone(), 104 None => return self.clone(),
105 }, 105 },
@@ -109,10 +109,6 @@ impl ast::ItemList {
109 [ws.ws().into(), item.syntax().clone().into()].into(); 109 [ws.ws().into(), item.syntax().clone().into()].into();
110 self.insert_children(position, to_insert) 110 self.insert_children(position, to_insert)
111 } 111 }
112
113 fn l_curly(&self) -> Option<SyntaxElement> {
114 self.syntax().children_with_tokens().find(|it| it.kind() == T!['{'])
115 }
116} 112}
117 113
118impl ast::RecordFieldList { 114impl ast::RecordFieldList {
@@ -147,7 +143,7 @@ impl ast::RecordFieldList {
147 macro_rules! after_l_curly { 143 macro_rules! after_l_curly {
148 () => {{ 144 () => {{
149 let anchor = match self.l_curly() { 145 let anchor = match self.l_curly() {
150 Some(it) => it, 146 Some(it) => it.syntax().clone().into(),
151 None => return self.clone(), 147 None => return self.clone(),
152 }; 148 };
153 InsertPosition::After(anchor) 149 InsertPosition::After(anchor)
@@ -189,24 +185,20 @@ impl ast::RecordFieldList {
189 185
190 self.insert_children(position, to_insert) 186 self.insert_children(position, to_insert)
191 } 187 }
192
193 fn l_curly(&self) -> Option<SyntaxElement> {
194 self.syntax().children_with_tokens().find(|it| it.kind() == T!['{'])
195 }
196} 188}
197 189
198impl ast::TypeParam { 190impl ast::TypeParam {
199 #[must_use] 191 #[must_use]
200 pub fn remove_bounds(&self) -> ast::TypeParam { 192 pub fn remove_bounds(&self) -> ast::TypeParam {
201 let colon = match self.colon_token() { 193 let colon = match self.colon() {
202 Some(it) => it, 194 Some(it) => it,
203 None => return self.clone(), 195 None => return self.clone(),
204 }; 196 };
205 let end = match self.type_bound_list() { 197 let end = match self.type_bound_list() {
206 Some(it) => it.syntax().clone().into(), 198 Some(it) => it.syntax().clone().into(),
207 None => colon.clone().into(), 199 None => colon.syntax().clone().into(),
208 }; 200 };
209 self.replace_children(colon.into()..=end, iter::empty()) 201 self.replace_children(colon.syntax().clone().into()..=end, iter::empty())
210 } 202 }
211} 203}
212 204
@@ -305,8 +297,12 @@ impl ast::UseTree {
305 Some(it) => it, 297 Some(it) => it,
306 None => return self.clone(), 298 None => return self.clone(),
307 }; 299 };
308 let use_tree = 300 let use_tree = make::use_tree(
309 make::use_tree(suffix.clone(), self.use_tree_list(), self.alias(), self.has_star()); 301 suffix.clone(),
302 self.use_tree_list(),
303 self.alias(),
304 self.star().is_some(),
305 );
310 let nested = make::use_tree_list(iter::once(use_tree)); 306 let nested = make::use_tree_list(iter::once(use_tree));
311 return make::use_tree(prefix.clone(), Some(nested), None, false); 307 return make::use_tree(prefix.clone(), Some(nested), None, false);
312 308
diff --git a/crates/ra_syntax/src/ast/expr_extensions.rs b/crates/ra_syntax/src/ast/expr_extensions.rs
index 8bbd946c0..40c8fca3b 100644
--- a/crates/ra_syntax/src/ast/expr_extensions.rs
+++ b/crates/ra_syntax/src/ast/expr_extensions.rs
@@ -52,6 +52,10 @@ impl ast::RefExpr {
52 pub fn is_mut(&self) -> bool { 52 pub fn is_mut(&self) -> bool {
53 self.syntax().children_with_tokens().any(|n| n.kind() == T![mut]) 53 self.syntax().children_with_tokens().any(|n| n.kind() == T![mut])
54 } 54 }
55
56 pub fn raw_token(&self) -> Option<SyntaxToken> {
57 None // FIXME: implement &raw
58 }
55} 59}
56 60
57#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] 61#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs
index bf7d137be..33fe60762 100644
--- a/crates/ra_syntax/src/ast/extensions.rs
+++ b/crates/ra_syntax/src/ast/extensions.rs
@@ -4,7 +4,9 @@
4use itertools::Itertools; 4use itertools::Itertools;
5 5
6use crate::{ 6use crate::{
7 ast::{self, child_opt, children, AstNode, AttrInput, NameOwner, SyntaxNode}, 7 ast::{
8 self, child_opt, children, support, AstNode, AstToken, AttrInput, NameOwner, SyntaxNode,
9 },
8 SmolStr, SyntaxElement, 10 SmolStr, SyntaxElement,
9 SyntaxKind::*, 11 SyntaxKind::*,
10 SyntaxToken, T, 12 SyntaxToken, T,
@@ -130,13 +132,6 @@ impl ast::PathSegment {
130 }; 132 };
131 Some(res) 133 Some(res)
132 } 134 }
133
134 pub fn has_colon_colon(&self) -> bool {
135 match self.syntax.first_child_or_token().map(|s| s.kind()) {
136 Some(T![::]) => true,
137 _ => false,
138 }
139 }
140} 135}
141 136
142impl ast::Path { 137impl ast::Path {
@@ -154,12 +149,6 @@ impl ast::Module {
154 } 149 }
155} 150}
156 151
157impl ast::UseTree {
158 pub fn has_star(&self) -> bool {
159 self.syntax().children_with_tokens().any(|it| it.kind() == T![*])
160 }
161}
162
163impl ast::UseTreeList { 152impl ast::UseTreeList {
164 pub fn parent_use_tree(&self) -> ast::UseTree { 153 pub fn parent_use_tree(&self) -> ast::UseTree {
165 self.syntax() 154 self.syntax()
@@ -167,20 +156,6 @@ impl ast::UseTreeList {
167 .and_then(ast::UseTree::cast) 156 .and_then(ast::UseTree::cast)
168 .expect("UseTreeLists are always nested in UseTrees") 157 .expect("UseTreeLists are always nested in UseTrees")
169 } 158 }
170 pub fn l_curly(&self) -> Option<SyntaxToken> {
171 self.token(T!['{'])
172 }
173
174 pub fn r_curly(&self) -> Option<SyntaxToken> {
175 self.token(T!['}'])
176 }
177
178 fn token(&self, kind: SyntaxKind) -> Option<SyntaxToken> {
179 self.syntax()
180 .children_with_tokens()
181 .filter_map(|it| it.into_token())
182 .find(|it| it.kind() == kind)
183 }
184} 159}
185 160
186impl ast::ImplDef { 161impl ast::ImplDef {
@@ -387,24 +362,9 @@ pub enum SelfParamKind {
387} 362}
388 363
389impl ast::SelfParam { 364impl ast::SelfParam {
390 pub fn self_kw_token(&self) -> SyntaxToken {
391 self.syntax()
392 .children_with_tokens()
393 .filter_map(|it| it.into_token())
394 .find(|it| it.kind() == T![self])
395 .expect("invalid tree: self param must have self")
396 }
397
398 pub fn kind(&self) -> SelfParamKind { 365 pub fn kind(&self) -> SelfParamKind {
399 let borrowed = self.syntax().children_with_tokens().any(|n| n.kind() == T![&]); 366 if self.amp().is_some() {
400 if borrowed { 367 if self.amp_mut_kw().is_some() {
401 // check for a `mut` coming after the & -- `mut &self` != `&mut self`
402 if self
403 .syntax()
404 .children_with_tokens()
405 .skip_while(|n| n.kind() != T![&])
406 .any(|n| n.kind() == T![mut])
407 {
408 SelfParamKind::MutRef 368 SelfParamKind::MutRef
409 } else { 369 } else {
410 SelfParamKind::Ref 370 SelfParamKind::Ref
@@ -413,32 +373,23 @@ impl ast::SelfParam {
413 SelfParamKind::Owned 373 SelfParamKind::Owned
414 } 374 }
415 } 375 }
416}
417 376
418impl ast::LifetimeParam { 377 /// the "mut" in "mut self", not the one in "&mut self"
419 pub fn lifetime_token(&self) -> Option<SyntaxToken> { 378 pub fn mut_kw(&self) -> Option<ast::MutKw> {
420 self.syntax() 379 self.syntax()
421 .children_with_tokens() 380 .children_with_tokens()
422 .filter_map(|it| it.into_token()) 381 .filter_map(|it| it.into_token())
423 .find(|it| it.kind() == LIFETIME) 382 .take_while(|it| it.kind() != T![&])
383 .find_map(ast::MutKw::cast)
424 } 384 }
425}
426 385
427impl ast::TypeParam { 386 /// the "mut" in "&mut self", not the one in "mut self"
428 pub fn colon_token(&self) -> Option<SyntaxToken> { 387 pub fn amp_mut_kw(&self) -> Option<ast::MutKw> {
429 self.syntax() 388 self.syntax()
430 .children_with_tokens() 389 .children_with_tokens()
431 .filter_map(|it| it.into_token()) 390 .filter_map(|it| it.into_token())
432 .find(|it| it.kind() == T![:]) 391 .skip_while(|it| it.kind() != T![&])
433 } 392 .find_map(ast::MutKw::cast)
434}
435
436impl ast::WherePred {
437 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
438 self.syntax()
439 .children_with_tokens()
440 .filter_map(|it| it.into_token())
441 .find(|it| it.kind() == LIFETIME)
442 } 393 }
443} 394}
444 395
@@ -449,7 +400,7 @@ pub enum TypeBoundKind {
449 /// for<'a> ... 400 /// for<'a> ...
450 ForType(ast::ForType), 401 ForType(ast::ForType),
451 /// 'a 402 /// 'a
452 Lifetime(ast::SyntaxToken), 403 Lifetime(ast::Lifetime),
453} 404}
454 405
455impl ast::TypeBound { 406impl ast::TypeBound {
@@ -465,21 +416,28 @@ impl ast::TypeBound {
465 } 416 }
466 } 417 }
467 418
468 fn lifetime(&self) -> Option<SyntaxToken> { 419 pub fn has_question_mark(&self) -> bool {
469 self.syntax() 420 self.question().is_some()
470 .children_with_tokens()
471 .filter_map(|it| it.into_token())
472 .find(|it| it.kind() == LIFETIME)
473 } 421 }
474 422
475 pub fn question_mark_token(&self) -> Option<SyntaxToken> { 423 pub fn const_question(&self) -> Option<ast::Question> {
476 self.syntax() 424 self.syntax()
477 .children_with_tokens() 425 .children_with_tokens()
478 .filter_map(|it| it.into_token()) 426 .filter_map(|it| it.into_token())
479 .find(|it| it.kind() == T![?]) 427 .take_while(|it| it.kind() != T![const])
428 .find_map(ast::Question::cast)
480 } 429 }
481 pub fn has_question_mark(&self) -> bool { 430
482 self.question_mark_token().is_some() 431 pub fn question(&self) -> Option<ast::Question> {
432 if self.const_kw().is_some() {
433 self.syntax()
434 .children_with_tokens()
435 .filter_map(|it| it.into_token())
436 .skip_while(|it| it.kind() != T![const])
437 .find_map(ast::Question::cast)
438 } else {
439 support::token(&self.syntax)
440 }
483 } 441 }
484} 442}
485 443
@@ -493,6 +451,7 @@ pub enum VisibilityKind {
493 In(ast::Path), 451 In(ast::Path),
494 PubCrate, 452 PubCrate,
495 PubSuper, 453 PubSuper,
454 PubSelf,
496 Pub, 455 Pub,
497} 456}
498 457
@@ -504,6 +463,8 @@ impl ast::Visibility {
504 VisibilityKind::PubCrate 463 VisibilityKind::PubCrate
505 } else if self.is_pub_super() { 464 } else if self.is_pub_super() {
506 VisibilityKind::PubSuper 465 VisibilityKind::PubSuper
466 } else if self.is_pub_self() {
467 VisibilityKind::PubSuper
507 } else { 468 } else {
508 VisibilityKind::Pub 469 VisibilityKind::Pub
509 } 470 }
@@ -516,6 +477,10 @@ impl ast::Visibility {
516 fn is_pub_super(&self) -> bool { 477 fn is_pub_super(&self) -> bool {
517 self.syntax().children_with_tokens().any(|it| it.kind() == T![super]) 478 self.syntax().children_with_tokens().any(|it| it.kind() == T![super])
518 } 479 }
480
481 fn is_pub_self(&self) -> bool {
482 self.syntax().children_with_tokens().any(|it| it.kind() == T![self])
483 }
519} 484}
520 485
521impl ast::MacroCall { 486impl ast::MacroCall {
@@ -528,3 +493,41 @@ impl ast::MacroCall {
528 } 493 }
529 } 494 }
530} 495}
496
497impl ast::LifetimeParam {
498 pub fn lifetime_bounds(&self) -> impl Iterator<Item = ast::Lifetime> {
499 self.syntax()
500 .children_with_tokens()
501 .filter_map(|it| it.into_token())
502 .skip_while(|x| x.kind() != T![:])
503 .filter_map(ast::Lifetime::cast)
504 }
505}
506
507impl ast::RangePat {
508 pub fn start(&self) -> Option<ast::Pat> {
509 self.syntax()
510 .children_with_tokens()
511 .take_while(|it| !ast::RangeSeparator::can_cast(it.kind()))
512 .filter_map(|it| it.into_node())
513 .find_map(ast::Pat::cast)
514 }
515
516 pub fn end(&self) -> Option<ast::Pat> {
517 self.syntax()
518 .children_with_tokens()
519 .skip_while(|it| !ast::RangeSeparator::can_cast(it.kind()))
520 .filter_map(|it| it.into_node())
521 .find_map(ast::Pat::cast)
522 }
523}
524
525impl ast::TokenTree {
526 pub fn left_delimiter(&self) -> Option<ast::LeftDelimiter> {
527 self.syntax().first_child_or_token()?.into_token().and_then(ast::LeftDelimiter::cast)
528 }
529
530 pub fn right_delimiter(&self) -> Option<ast::RightDelimiter> {
531 self.syntax().last_child_or_token()?.into_token().and_then(ast::RightDelimiter::cast)
532 }
533}
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index d2b055b0a..f5199e09f 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -1,7877 +1,6 @@
1//! Generated file, do not edit by hand, see `xtask/src/codegen` 1//! This file is actually hand-written, but the submodules are indeed generated.
2 2
3#[allow(unused_imports)] 3#[rustfmt::skip]
4use crate::{ 4pub(super) mod nodes;
5 ast::{self, AstChildren, AstNode, AstToken}, 5#[rustfmt::skip]
6 NodeOrToken, SyntaxElement, 6pub(super) mod tokens;
7 SyntaxKind::{self, *},
8 SyntaxNode, SyntaxToken,
9};
10#[derive(Debug, Clone, PartialEq, Eq, Hash)]
11pub struct Semi {
12 pub(crate) syntax: SyntaxToken,
13}
14impl std::fmt::Display for Semi {
15 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
16 std::fmt::Display::fmt(&self.syntax, f)
17 }
18}
19impl AstToken for Semi {
20 fn can_cast(kind: SyntaxKind) -> bool {
21 match kind {
22 SEMI => true,
23 _ => false,
24 }
25 }
26 fn cast(syntax: SyntaxToken) -> Option<Self> {
27 if Self::can_cast(syntax.kind()) {
28 Some(Self { syntax })
29 } else {
30 None
31 }
32 }
33 fn syntax(&self) -> &SyntaxToken {
34 &self.syntax
35 }
36}
37#[derive(Debug, Clone, PartialEq, Eq, Hash)]
38pub struct Comma {
39 pub(crate) syntax: SyntaxToken,
40}
41impl std::fmt::Display for Comma {
42 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
43 std::fmt::Display::fmt(&self.syntax, f)
44 }
45}
46impl AstToken for Comma {
47 fn can_cast(kind: SyntaxKind) -> bool {
48 match kind {
49 COMMA => true,
50 _ => false,
51 }
52 }
53 fn cast(syntax: SyntaxToken) -> Option<Self> {
54 if Self::can_cast(syntax.kind()) {
55 Some(Self { syntax })
56 } else {
57 None
58 }
59 }
60 fn syntax(&self) -> &SyntaxToken {
61 &self.syntax
62 }
63}
64#[derive(Debug, Clone, PartialEq, Eq, Hash)]
65pub struct LParen {
66 pub(crate) syntax: SyntaxToken,
67}
68impl std::fmt::Display for LParen {
69 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
70 std::fmt::Display::fmt(&self.syntax, f)
71 }
72}
73impl AstToken for LParen {
74 fn can_cast(kind: SyntaxKind) -> bool {
75 match kind {
76 L_PAREN => true,
77 _ => false,
78 }
79 }
80 fn cast(syntax: SyntaxToken) -> Option<Self> {
81 if Self::can_cast(syntax.kind()) {
82 Some(Self { syntax })
83 } else {
84 None
85 }
86 }
87 fn syntax(&self) -> &SyntaxToken {
88 &self.syntax
89 }
90}
91#[derive(Debug, Clone, PartialEq, Eq, Hash)]
92pub struct RParen {
93 pub(crate) syntax: SyntaxToken,
94}
95impl std::fmt::Display for RParen {
96 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
97 std::fmt::Display::fmt(&self.syntax, f)
98 }
99}
100impl AstToken for RParen {
101 fn can_cast(kind: SyntaxKind) -> bool {
102 match kind {
103 R_PAREN => true,
104 _ => false,
105 }
106 }
107 fn cast(syntax: SyntaxToken) -> Option<Self> {
108 if Self::can_cast(syntax.kind()) {
109 Some(Self { syntax })
110 } else {
111 None
112 }
113 }
114 fn syntax(&self) -> &SyntaxToken {
115 &self.syntax
116 }
117}
118#[derive(Debug, Clone, PartialEq, Eq, Hash)]
119pub struct LCurly {
120 pub(crate) syntax: SyntaxToken,
121}
122impl std::fmt::Display for LCurly {
123 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
124 std::fmt::Display::fmt(&self.syntax, f)
125 }
126}
127impl AstToken for LCurly {
128 fn can_cast(kind: SyntaxKind) -> bool {
129 match kind {
130 L_CURLY => true,
131 _ => false,
132 }
133 }
134 fn cast(syntax: SyntaxToken) -> Option<Self> {
135 if Self::can_cast(syntax.kind()) {
136 Some(Self { syntax })
137 } else {
138 None
139 }
140 }
141 fn syntax(&self) -> &SyntaxToken {
142 &self.syntax
143 }
144}
145#[derive(Debug, Clone, PartialEq, Eq, Hash)]
146pub struct RCurly {
147 pub(crate) syntax: SyntaxToken,
148}
149impl std::fmt::Display for RCurly {
150 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
151 std::fmt::Display::fmt(&self.syntax, f)
152 }
153}
154impl AstToken for RCurly {
155 fn can_cast(kind: SyntaxKind) -> bool {
156 match kind {
157 R_CURLY => true,
158 _ => false,
159 }
160 }
161 fn cast(syntax: SyntaxToken) -> Option<Self> {
162 if Self::can_cast(syntax.kind()) {
163 Some(Self { syntax })
164 } else {
165 None
166 }
167 }
168 fn syntax(&self) -> &SyntaxToken {
169 &self.syntax
170 }
171}
172#[derive(Debug, Clone, PartialEq, Eq, Hash)]
173pub struct LBrack {
174 pub(crate) syntax: SyntaxToken,
175}
176impl std::fmt::Display for LBrack {
177 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
178 std::fmt::Display::fmt(&self.syntax, f)
179 }
180}
181impl AstToken for LBrack {
182 fn can_cast(kind: SyntaxKind) -> bool {
183 match kind {
184 L_BRACK => true,
185 _ => false,
186 }
187 }
188 fn cast(syntax: SyntaxToken) -> Option<Self> {
189 if Self::can_cast(syntax.kind()) {
190 Some(Self { syntax })
191 } else {
192 None
193 }
194 }
195 fn syntax(&self) -> &SyntaxToken {
196 &self.syntax
197 }
198}
199#[derive(Debug, Clone, PartialEq, Eq, Hash)]
200pub struct RBrack {
201 pub(crate) syntax: SyntaxToken,
202}
203impl std::fmt::Display for RBrack {
204 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
205 std::fmt::Display::fmt(&self.syntax, f)
206 }
207}
208impl AstToken for RBrack {
209 fn can_cast(kind: SyntaxKind) -> bool {
210 match kind {
211 R_BRACK => true,
212 _ => false,
213 }
214 }
215 fn cast(syntax: SyntaxToken) -> Option<Self> {
216 if Self::can_cast(syntax.kind()) {
217 Some(Self { syntax })
218 } else {
219 None
220 }
221 }
222 fn syntax(&self) -> &SyntaxToken {
223 &self.syntax
224 }
225}
226#[derive(Debug, Clone, PartialEq, Eq, Hash)]
227pub struct LAngle {
228 pub(crate) syntax: SyntaxToken,
229}
230impl std::fmt::Display for LAngle {
231 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
232 std::fmt::Display::fmt(&self.syntax, f)
233 }
234}
235impl AstToken for LAngle {
236 fn can_cast(kind: SyntaxKind) -> bool {
237 match kind {
238 L_ANGLE => true,
239 _ => false,
240 }
241 }
242 fn cast(syntax: SyntaxToken) -> Option<Self> {
243 if Self::can_cast(syntax.kind()) {
244 Some(Self { syntax })
245 } else {
246 None
247 }
248 }
249 fn syntax(&self) -> &SyntaxToken {
250 &self.syntax
251 }
252}
253#[derive(Debug, Clone, PartialEq, Eq, Hash)]
254pub struct RAngle {
255 pub(crate) syntax: SyntaxToken,
256}
257impl std::fmt::Display for RAngle {
258 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
259 std::fmt::Display::fmt(&self.syntax, f)
260 }
261}
262impl AstToken for RAngle {
263 fn can_cast(kind: SyntaxKind) -> bool {
264 match kind {
265 R_ANGLE => true,
266 _ => false,
267 }
268 }
269 fn cast(syntax: SyntaxToken) -> Option<Self> {
270 if Self::can_cast(syntax.kind()) {
271 Some(Self { syntax })
272 } else {
273 None
274 }
275 }
276 fn syntax(&self) -> &SyntaxToken {
277 &self.syntax
278 }
279}
280#[derive(Debug, Clone, PartialEq, Eq, Hash)]
281pub struct At {
282 pub(crate) syntax: SyntaxToken,
283}
284impl std::fmt::Display for At {
285 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
286 std::fmt::Display::fmt(&self.syntax, f)
287 }
288}
289impl AstToken for At {
290 fn can_cast(kind: SyntaxKind) -> bool {
291 match kind {
292 AT => true,
293 _ => false,
294 }
295 }
296 fn cast(syntax: SyntaxToken) -> Option<Self> {
297 if Self::can_cast(syntax.kind()) {
298 Some(Self { syntax })
299 } else {
300 None
301 }
302 }
303 fn syntax(&self) -> &SyntaxToken {
304 &self.syntax
305 }
306}
307#[derive(Debug, Clone, PartialEq, Eq, Hash)]
308pub struct Pound {
309 pub(crate) syntax: SyntaxToken,
310}
311impl std::fmt::Display for Pound {
312 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
313 std::fmt::Display::fmt(&self.syntax, f)
314 }
315}
316impl AstToken for Pound {
317 fn can_cast(kind: SyntaxKind) -> bool {
318 match kind {
319 POUND => true,
320 _ => false,
321 }
322 }
323 fn cast(syntax: SyntaxToken) -> Option<Self> {
324 if Self::can_cast(syntax.kind()) {
325 Some(Self { syntax })
326 } else {
327 None
328 }
329 }
330 fn syntax(&self) -> &SyntaxToken {
331 &self.syntax
332 }
333}
334#[derive(Debug, Clone, PartialEq, Eq, Hash)]
335pub struct Tilde {
336 pub(crate) syntax: SyntaxToken,
337}
338impl std::fmt::Display for Tilde {
339 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
340 std::fmt::Display::fmt(&self.syntax, f)
341 }
342}
343impl AstToken for Tilde {
344 fn can_cast(kind: SyntaxKind) -> bool {
345 match kind {
346 TILDE => true,
347 _ => false,
348 }
349 }
350 fn cast(syntax: SyntaxToken) -> Option<Self> {
351 if Self::can_cast(syntax.kind()) {
352 Some(Self { syntax })
353 } else {
354 None
355 }
356 }
357 fn syntax(&self) -> &SyntaxToken {
358 &self.syntax
359 }
360}
361#[derive(Debug, Clone, PartialEq, Eq, Hash)]
362pub struct Question {
363 pub(crate) syntax: SyntaxToken,
364}
365impl std::fmt::Display for Question {
366 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
367 std::fmt::Display::fmt(&self.syntax, f)
368 }
369}
370impl AstToken for Question {
371 fn can_cast(kind: SyntaxKind) -> bool {
372 match kind {
373 QUESTION => true,
374 _ => false,
375 }
376 }
377 fn cast(syntax: SyntaxToken) -> Option<Self> {
378 if Self::can_cast(syntax.kind()) {
379 Some(Self { syntax })
380 } else {
381 None
382 }
383 }
384 fn syntax(&self) -> &SyntaxToken {
385 &self.syntax
386 }
387}
388#[derive(Debug, Clone, PartialEq, Eq, Hash)]
389pub struct Dollar {
390 pub(crate) syntax: SyntaxToken,
391}
392impl std::fmt::Display for Dollar {
393 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
394 std::fmt::Display::fmt(&self.syntax, f)
395 }
396}
397impl AstToken for Dollar {
398 fn can_cast(kind: SyntaxKind) -> bool {
399 match kind {
400 DOLLAR => true,
401 _ => false,
402 }
403 }
404 fn cast(syntax: SyntaxToken) -> Option<Self> {
405 if Self::can_cast(syntax.kind()) {
406 Some(Self { syntax })
407 } else {
408 None
409 }
410 }
411 fn syntax(&self) -> &SyntaxToken {
412 &self.syntax
413 }
414}
415#[derive(Debug, Clone, PartialEq, Eq, Hash)]
416pub struct Amp {
417 pub(crate) syntax: SyntaxToken,
418}
419impl std::fmt::Display for Amp {
420 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
421 std::fmt::Display::fmt(&self.syntax, f)
422 }
423}
424impl AstToken for Amp {
425 fn can_cast(kind: SyntaxKind) -> bool {
426 match kind {
427 AMP => true,
428 _ => false,
429 }
430 }
431 fn cast(syntax: SyntaxToken) -> Option<Self> {
432 if Self::can_cast(syntax.kind()) {
433 Some(Self { syntax })
434 } else {
435 None
436 }
437 }
438 fn syntax(&self) -> &SyntaxToken {
439 &self.syntax
440 }
441}
442#[derive(Debug, Clone, PartialEq, Eq, Hash)]
443pub struct Pipe {
444 pub(crate) syntax: SyntaxToken,
445}
446impl std::fmt::Display for Pipe {
447 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
448 std::fmt::Display::fmt(&self.syntax, f)
449 }
450}
451impl AstToken for Pipe {
452 fn can_cast(kind: SyntaxKind) -> bool {
453 match kind {
454 PIPE => true,
455 _ => false,
456 }
457 }
458 fn cast(syntax: SyntaxToken) -> Option<Self> {
459 if Self::can_cast(syntax.kind()) {
460 Some(Self { syntax })
461 } else {
462 None
463 }
464 }
465 fn syntax(&self) -> &SyntaxToken {
466 &self.syntax
467 }
468}
469#[derive(Debug, Clone, PartialEq, Eq, Hash)]
470pub struct Plus {
471 pub(crate) syntax: SyntaxToken,
472}
473impl std::fmt::Display for Plus {
474 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
475 std::fmt::Display::fmt(&self.syntax, f)
476 }
477}
478impl AstToken for Plus {
479 fn can_cast(kind: SyntaxKind) -> bool {
480 match kind {
481 PLUS => true,
482 _ => false,
483 }
484 }
485 fn cast(syntax: SyntaxToken) -> Option<Self> {
486 if Self::can_cast(syntax.kind()) {
487 Some(Self { syntax })
488 } else {
489 None
490 }
491 }
492 fn syntax(&self) -> &SyntaxToken {
493 &self.syntax
494 }
495}
496#[derive(Debug, Clone, PartialEq, Eq, Hash)]
497pub struct Star {
498 pub(crate) syntax: SyntaxToken,
499}
500impl std::fmt::Display for Star {
501 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
502 std::fmt::Display::fmt(&self.syntax, f)
503 }
504}
505impl AstToken for Star {
506 fn can_cast(kind: SyntaxKind) -> bool {
507 match kind {
508 STAR => true,
509 _ => false,
510 }
511 }
512 fn cast(syntax: SyntaxToken) -> Option<Self> {
513 if Self::can_cast(syntax.kind()) {
514 Some(Self { syntax })
515 } else {
516 None
517 }
518 }
519 fn syntax(&self) -> &SyntaxToken {
520 &self.syntax
521 }
522}
523#[derive(Debug, Clone, PartialEq, Eq, Hash)]
524pub struct Slash {
525 pub(crate) syntax: SyntaxToken,
526}
527impl std::fmt::Display for Slash {
528 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
529 std::fmt::Display::fmt(&self.syntax, f)
530 }
531}
532impl AstToken for Slash {
533 fn can_cast(kind: SyntaxKind) -> bool {
534 match kind {
535 SLASH => true,
536 _ => false,
537 }
538 }
539 fn cast(syntax: SyntaxToken) -> Option<Self> {
540 if Self::can_cast(syntax.kind()) {
541 Some(Self { syntax })
542 } else {
543 None
544 }
545 }
546 fn syntax(&self) -> &SyntaxToken {
547 &self.syntax
548 }
549}
550#[derive(Debug, Clone, PartialEq, Eq, Hash)]
551pub struct Caret {
552 pub(crate) syntax: SyntaxToken,
553}
554impl std::fmt::Display for Caret {
555 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
556 std::fmt::Display::fmt(&self.syntax, f)
557 }
558}
559impl AstToken for Caret {
560 fn can_cast(kind: SyntaxKind) -> bool {
561 match kind {
562 CARET => true,
563 _ => false,
564 }
565 }
566 fn cast(syntax: SyntaxToken) -> Option<Self> {
567 if Self::can_cast(syntax.kind()) {
568 Some(Self { syntax })
569 } else {
570 None
571 }
572 }
573 fn syntax(&self) -> &SyntaxToken {
574 &self.syntax
575 }
576}
577#[derive(Debug, Clone, PartialEq, Eq, Hash)]
578pub struct Percent {
579 pub(crate) syntax: SyntaxToken,
580}
581impl std::fmt::Display for Percent {
582 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
583 std::fmt::Display::fmt(&self.syntax, f)
584 }
585}
586impl AstToken for Percent {
587 fn can_cast(kind: SyntaxKind) -> bool {
588 match kind {
589 PERCENT => true,
590 _ => false,
591 }
592 }
593 fn cast(syntax: SyntaxToken) -> Option<Self> {
594 if Self::can_cast(syntax.kind()) {
595 Some(Self { syntax })
596 } else {
597 None
598 }
599 }
600 fn syntax(&self) -> &SyntaxToken {
601 &self.syntax
602 }
603}
604#[derive(Debug, Clone, PartialEq, Eq, Hash)]
605pub struct Underscore {
606 pub(crate) syntax: SyntaxToken,
607}
608impl std::fmt::Display for Underscore {
609 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
610 std::fmt::Display::fmt(&self.syntax, f)
611 }
612}
613impl AstToken for Underscore {
614 fn can_cast(kind: SyntaxKind) -> bool {
615 match kind {
616 UNDERSCORE => true,
617 _ => false,
618 }
619 }
620 fn cast(syntax: SyntaxToken) -> Option<Self> {
621 if Self::can_cast(syntax.kind()) {
622 Some(Self { syntax })
623 } else {
624 None
625 }
626 }
627 fn syntax(&self) -> &SyntaxToken {
628 &self.syntax
629 }
630}
631#[derive(Debug, Clone, PartialEq, Eq, Hash)]
632pub struct Dot {
633 pub(crate) syntax: SyntaxToken,
634}
635impl std::fmt::Display for Dot {
636 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
637 std::fmt::Display::fmt(&self.syntax, f)
638 }
639}
640impl AstToken for Dot {
641 fn can_cast(kind: SyntaxKind) -> bool {
642 match kind {
643 DOT => true,
644 _ => false,
645 }
646 }
647 fn cast(syntax: SyntaxToken) -> Option<Self> {
648 if Self::can_cast(syntax.kind()) {
649 Some(Self { syntax })
650 } else {
651 None
652 }
653 }
654 fn syntax(&self) -> &SyntaxToken {
655 &self.syntax
656 }
657}
658#[derive(Debug, Clone, PartialEq, Eq, Hash)]
659pub struct Dotdot {
660 pub(crate) syntax: SyntaxToken,
661}
662impl std::fmt::Display for Dotdot {
663 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
664 std::fmt::Display::fmt(&self.syntax, f)
665 }
666}
667impl AstToken for Dotdot {
668 fn can_cast(kind: SyntaxKind) -> bool {
669 match kind {
670 DOTDOT => true,
671 _ => false,
672 }
673 }
674 fn cast(syntax: SyntaxToken) -> Option<Self> {
675 if Self::can_cast(syntax.kind()) {
676 Some(Self { syntax })
677 } else {
678 None
679 }
680 }
681 fn syntax(&self) -> &SyntaxToken {
682 &self.syntax
683 }
684}
685#[derive(Debug, Clone, PartialEq, Eq, Hash)]
686pub struct Dotdotdot {
687 pub(crate) syntax: SyntaxToken,
688}
689impl std::fmt::Display for Dotdotdot {
690 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
691 std::fmt::Display::fmt(&self.syntax, f)
692 }
693}
694impl AstToken for Dotdotdot {
695 fn can_cast(kind: SyntaxKind) -> bool {
696 match kind {
697 DOTDOTDOT => true,
698 _ => false,
699 }
700 }
701 fn cast(syntax: SyntaxToken) -> Option<Self> {
702 if Self::can_cast(syntax.kind()) {
703 Some(Self { syntax })
704 } else {
705 None
706 }
707 }
708 fn syntax(&self) -> &SyntaxToken {
709 &self.syntax
710 }
711}
712#[derive(Debug, Clone, PartialEq, Eq, Hash)]
713pub struct Dotdoteq {
714 pub(crate) syntax: SyntaxToken,
715}
716impl std::fmt::Display for Dotdoteq {
717 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
718 std::fmt::Display::fmt(&self.syntax, f)
719 }
720}
721impl AstToken for Dotdoteq {
722 fn can_cast(kind: SyntaxKind) -> bool {
723 match kind {
724 DOTDOTEQ => true,
725 _ => false,
726 }
727 }
728 fn cast(syntax: SyntaxToken) -> Option<Self> {
729 if Self::can_cast(syntax.kind()) {
730 Some(Self { syntax })
731 } else {
732 None
733 }
734 }
735 fn syntax(&self) -> &SyntaxToken {
736 &self.syntax
737 }
738}
739#[derive(Debug, Clone, PartialEq, Eq, Hash)]
740pub struct Colon {
741 pub(crate) syntax: SyntaxToken,
742}
743impl std::fmt::Display for Colon {
744 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
745 std::fmt::Display::fmt(&self.syntax, f)
746 }
747}
748impl AstToken for Colon {
749 fn can_cast(kind: SyntaxKind) -> bool {
750 match kind {
751 COLON => true,
752 _ => false,
753 }
754 }
755 fn cast(syntax: SyntaxToken) -> Option<Self> {
756 if Self::can_cast(syntax.kind()) {
757 Some(Self { syntax })
758 } else {
759 None
760 }
761 }
762 fn syntax(&self) -> &SyntaxToken {
763 &self.syntax
764 }
765}
766#[derive(Debug, Clone, PartialEq, Eq, Hash)]
767pub struct Coloncolon {
768 pub(crate) syntax: SyntaxToken,
769}
770impl std::fmt::Display for Coloncolon {
771 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
772 std::fmt::Display::fmt(&self.syntax, f)
773 }
774}
775impl AstToken for Coloncolon {
776 fn can_cast(kind: SyntaxKind) -> bool {
777 match kind {
778 COLONCOLON => true,
779 _ => false,
780 }
781 }
782 fn cast(syntax: SyntaxToken) -> Option<Self> {
783 if Self::can_cast(syntax.kind()) {
784 Some(Self { syntax })
785 } else {
786 None
787 }
788 }
789 fn syntax(&self) -> &SyntaxToken {
790 &self.syntax
791 }
792}
793#[derive(Debug, Clone, PartialEq, Eq, Hash)]
794pub struct Eq {
795 pub(crate) syntax: SyntaxToken,
796}
797impl std::fmt::Display for Eq {
798 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
799 std::fmt::Display::fmt(&self.syntax, f)
800 }
801}
802impl AstToken for Eq {
803 fn can_cast(kind: SyntaxKind) -> bool {
804 match kind {
805 EQ => true,
806 _ => false,
807 }
808 }
809 fn cast(syntax: SyntaxToken) -> Option<Self> {
810 if Self::can_cast(syntax.kind()) {
811 Some(Self { syntax })
812 } else {
813 None
814 }
815 }
816 fn syntax(&self) -> &SyntaxToken {
817 &self.syntax
818 }
819}
820#[derive(Debug, Clone, PartialEq, Eq, Hash)]
821pub struct Eqeq {
822 pub(crate) syntax: SyntaxToken,
823}
824impl std::fmt::Display for Eqeq {
825 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
826 std::fmt::Display::fmt(&self.syntax, f)
827 }
828}
829impl AstToken for Eqeq {
830 fn can_cast(kind: SyntaxKind) -> bool {
831 match kind {
832 EQEQ => true,
833 _ => false,
834 }
835 }
836 fn cast(syntax: SyntaxToken) -> Option<Self> {
837 if Self::can_cast(syntax.kind()) {
838 Some(Self { syntax })
839 } else {
840 None
841 }
842 }
843 fn syntax(&self) -> &SyntaxToken {
844 &self.syntax
845 }
846}
847#[derive(Debug, Clone, PartialEq, Eq, Hash)]
848pub struct FatArrow {
849 pub(crate) syntax: SyntaxToken,
850}
851impl std::fmt::Display for FatArrow {
852 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
853 std::fmt::Display::fmt(&self.syntax, f)
854 }
855}
856impl AstToken for FatArrow {
857 fn can_cast(kind: SyntaxKind) -> bool {
858 match kind {
859 FAT_ARROW => true,
860 _ => false,
861 }
862 }
863 fn cast(syntax: SyntaxToken) -> Option<Self> {
864 if Self::can_cast(syntax.kind()) {
865 Some(Self { syntax })
866 } else {
867 None
868 }
869 }
870 fn syntax(&self) -> &SyntaxToken {
871 &self.syntax
872 }
873}
874#[derive(Debug, Clone, PartialEq, Eq, Hash)]
875pub struct Excl {
876 pub(crate) syntax: SyntaxToken,
877}
878impl std::fmt::Display for Excl {
879 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
880 std::fmt::Display::fmt(&self.syntax, f)
881 }
882}
883impl AstToken for Excl {
884 fn can_cast(kind: SyntaxKind) -> bool {
885 match kind {
886 EXCL => true,
887 _ => false,
888 }
889 }
890 fn cast(syntax: SyntaxToken) -> Option<Self> {
891 if Self::can_cast(syntax.kind()) {
892 Some(Self { syntax })
893 } else {
894 None
895 }
896 }
897 fn syntax(&self) -> &SyntaxToken {
898 &self.syntax
899 }
900}
901#[derive(Debug, Clone, PartialEq, Eq, Hash)]
902pub struct Neq {
903 pub(crate) syntax: SyntaxToken,
904}
905impl std::fmt::Display for Neq {
906 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
907 std::fmt::Display::fmt(&self.syntax, f)
908 }
909}
910impl AstToken for Neq {
911 fn can_cast(kind: SyntaxKind) -> bool {
912 match kind {
913 NEQ => true,
914 _ => false,
915 }
916 }
917 fn cast(syntax: SyntaxToken) -> Option<Self> {
918 if Self::can_cast(syntax.kind()) {
919 Some(Self { syntax })
920 } else {
921 None
922 }
923 }
924 fn syntax(&self) -> &SyntaxToken {
925 &self.syntax
926 }
927}
928#[derive(Debug, Clone, PartialEq, Eq, Hash)]
929pub struct Minus {
930 pub(crate) syntax: SyntaxToken,
931}
932impl std::fmt::Display for Minus {
933 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
934 std::fmt::Display::fmt(&self.syntax, f)
935 }
936}
937impl AstToken for Minus {
938 fn can_cast(kind: SyntaxKind) -> bool {
939 match kind {
940 MINUS => true,
941 _ => false,
942 }
943 }
944 fn cast(syntax: SyntaxToken) -> Option<Self> {
945 if Self::can_cast(syntax.kind()) {
946 Some(Self { syntax })
947 } else {
948 None
949 }
950 }
951 fn syntax(&self) -> &SyntaxToken {
952 &self.syntax
953 }
954}
955#[derive(Debug, Clone, PartialEq, Eq, Hash)]
956pub struct ThinArrow {
957 pub(crate) syntax: SyntaxToken,
958}
959impl std::fmt::Display for ThinArrow {
960 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
961 std::fmt::Display::fmt(&self.syntax, f)
962 }
963}
964impl AstToken for ThinArrow {
965 fn can_cast(kind: SyntaxKind) -> bool {
966 match kind {
967 THIN_ARROW => true,
968 _ => false,
969 }
970 }
971 fn cast(syntax: SyntaxToken) -> Option<Self> {
972 if Self::can_cast(syntax.kind()) {
973 Some(Self { syntax })
974 } else {
975 None
976 }
977 }
978 fn syntax(&self) -> &SyntaxToken {
979 &self.syntax
980 }
981}
982#[derive(Debug, Clone, PartialEq, Eq, Hash)]
983pub struct Lteq {
984 pub(crate) syntax: SyntaxToken,
985}
986impl std::fmt::Display for Lteq {
987 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
988 std::fmt::Display::fmt(&self.syntax, f)
989 }
990}
991impl AstToken for Lteq {
992 fn can_cast(kind: SyntaxKind) -> bool {
993 match kind {
994 LTEQ => true,
995 _ => false,
996 }
997 }
998 fn cast(syntax: SyntaxToken) -> Option<Self> {
999 if Self::can_cast(syntax.kind()) {
1000 Some(Self { syntax })
1001 } else {
1002 None
1003 }
1004 }
1005 fn syntax(&self) -> &SyntaxToken {
1006 &self.syntax
1007 }
1008}
1009#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1010pub struct Gteq {
1011 pub(crate) syntax: SyntaxToken,
1012}
1013impl std::fmt::Display for Gteq {
1014 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1015 std::fmt::Display::fmt(&self.syntax, f)
1016 }
1017}
1018impl AstToken for Gteq {
1019 fn can_cast(kind: SyntaxKind) -> bool {
1020 match kind {
1021 GTEQ => true,
1022 _ => false,
1023 }
1024 }
1025 fn cast(syntax: SyntaxToken) -> Option<Self> {
1026 if Self::can_cast(syntax.kind()) {
1027 Some(Self { syntax })
1028 } else {
1029 None
1030 }
1031 }
1032 fn syntax(&self) -> &SyntaxToken {
1033 &self.syntax
1034 }
1035}
1036#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1037pub struct Pluseq {
1038 pub(crate) syntax: SyntaxToken,
1039}
1040impl std::fmt::Display for Pluseq {
1041 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1042 std::fmt::Display::fmt(&self.syntax, f)
1043 }
1044}
1045impl AstToken for Pluseq {
1046 fn can_cast(kind: SyntaxKind) -> bool {
1047 match kind {
1048 PLUSEQ => true,
1049 _ => false,
1050 }
1051 }
1052 fn cast(syntax: SyntaxToken) -> Option<Self> {
1053 if Self::can_cast(syntax.kind()) {
1054 Some(Self { syntax })
1055 } else {
1056 None
1057 }
1058 }
1059 fn syntax(&self) -> &SyntaxToken {
1060 &self.syntax
1061 }
1062}
1063#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1064pub struct Minuseq {
1065 pub(crate) syntax: SyntaxToken,
1066}
1067impl std::fmt::Display for Minuseq {
1068 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1069 std::fmt::Display::fmt(&self.syntax, f)
1070 }
1071}
1072impl AstToken for Minuseq {
1073 fn can_cast(kind: SyntaxKind) -> bool {
1074 match kind {
1075 MINUSEQ => true,
1076 _ => false,
1077 }
1078 }
1079 fn cast(syntax: SyntaxToken) -> Option<Self> {
1080 if Self::can_cast(syntax.kind()) {
1081 Some(Self { syntax })
1082 } else {
1083 None
1084 }
1085 }
1086 fn syntax(&self) -> &SyntaxToken {
1087 &self.syntax
1088 }
1089}
1090#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1091pub struct Pipeeq {
1092 pub(crate) syntax: SyntaxToken,
1093}
1094impl std::fmt::Display for Pipeeq {
1095 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1096 std::fmt::Display::fmt(&self.syntax, f)
1097 }
1098}
1099impl AstToken for Pipeeq {
1100 fn can_cast(kind: SyntaxKind) -> bool {
1101 match kind {
1102 PIPEEQ => true,
1103 _ => false,
1104 }
1105 }
1106 fn cast(syntax: SyntaxToken) -> Option<Self> {
1107 if Self::can_cast(syntax.kind()) {
1108 Some(Self { syntax })
1109 } else {
1110 None
1111 }
1112 }
1113 fn syntax(&self) -> &SyntaxToken {
1114 &self.syntax
1115 }
1116}
1117#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1118pub struct Ampeq {
1119 pub(crate) syntax: SyntaxToken,
1120}
1121impl std::fmt::Display for Ampeq {
1122 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1123 std::fmt::Display::fmt(&self.syntax, f)
1124 }
1125}
1126impl AstToken for Ampeq {
1127 fn can_cast(kind: SyntaxKind) -> bool {
1128 match kind {
1129 AMPEQ => true,
1130 _ => false,
1131 }
1132 }
1133 fn cast(syntax: SyntaxToken) -> Option<Self> {
1134 if Self::can_cast(syntax.kind()) {
1135 Some(Self { syntax })
1136 } else {
1137 None
1138 }
1139 }
1140 fn syntax(&self) -> &SyntaxToken {
1141 &self.syntax
1142 }
1143}
1144#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1145pub struct Careteq {
1146 pub(crate) syntax: SyntaxToken,
1147}
1148impl std::fmt::Display for Careteq {
1149 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1150 std::fmt::Display::fmt(&self.syntax, f)
1151 }
1152}
1153impl AstToken for Careteq {
1154 fn can_cast(kind: SyntaxKind) -> bool {
1155 match kind {
1156 CARETEQ => true,
1157 _ => false,
1158 }
1159 }
1160 fn cast(syntax: SyntaxToken) -> Option<Self> {
1161 if Self::can_cast(syntax.kind()) {
1162 Some(Self { syntax })
1163 } else {
1164 None
1165 }
1166 }
1167 fn syntax(&self) -> &SyntaxToken {
1168 &self.syntax
1169 }
1170}
1171#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1172pub struct Slasheq {
1173 pub(crate) syntax: SyntaxToken,
1174}
1175impl std::fmt::Display for Slasheq {
1176 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1177 std::fmt::Display::fmt(&self.syntax, f)
1178 }
1179}
1180impl AstToken for Slasheq {
1181 fn can_cast(kind: SyntaxKind) -> bool {
1182 match kind {
1183 SLASHEQ => true,
1184 _ => false,
1185 }
1186 }
1187 fn cast(syntax: SyntaxToken) -> Option<Self> {
1188 if Self::can_cast(syntax.kind()) {
1189 Some(Self { syntax })
1190 } else {
1191 None
1192 }
1193 }
1194 fn syntax(&self) -> &SyntaxToken {
1195 &self.syntax
1196 }
1197}
1198#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1199pub struct Stareq {
1200 pub(crate) syntax: SyntaxToken,
1201}
1202impl std::fmt::Display for Stareq {
1203 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1204 std::fmt::Display::fmt(&self.syntax, f)
1205 }
1206}
1207impl AstToken for Stareq {
1208 fn can_cast(kind: SyntaxKind) -> bool {
1209 match kind {
1210 STAREQ => true,
1211 _ => false,
1212 }
1213 }
1214 fn cast(syntax: SyntaxToken) -> Option<Self> {
1215 if Self::can_cast(syntax.kind()) {
1216 Some(Self { syntax })
1217 } else {
1218 None
1219 }
1220 }
1221 fn syntax(&self) -> &SyntaxToken {
1222 &self.syntax
1223 }
1224}
1225#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1226pub struct Percenteq {
1227 pub(crate) syntax: SyntaxToken,
1228}
1229impl std::fmt::Display for Percenteq {
1230 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1231 std::fmt::Display::fmt(&self.syntax, f)
1232 }
1233}
1234impl AstToken for Percenteq {
1235 fn can_cast(kind: SyntaxKind) -> bool {
1236 match kind {
1237 PERCENTEQ => true,
1238 _ => false,
1239 }
1240 }
1241 fn cast(syntax: SyntaxToken) -> Option<Self> {
1242 if Self::can_cast(syntax.kind()) {
1243 Some(Self { syntax })
1244 } else {
1245 None
1246 }
1247 }
1248 fn syntax(&self) -> &SyntaxToken {
1249 &self.syntax
1250 }
1251}
1252#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1253pub struct Ampamp {
1254 pub(crate) syntax: SyntaxToken,
1255}
1256impl std::fmt::Display for Ampamp {
1257 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1258 std::fmt::Display::fmt(&self.syntax, f)
1259 }
1260}
1261impl AstToken for Ampamp {
1262 fn can_cast(kind: SyntaxKind) -> bool {
1263 match kind {
1264 AMPAMP => true,
1265 _ => false,
1266 }
1267 }
1268 fn cast(syntax: SyntaxToken) -> Option<Self> {
1269 if Self::can_cast(syntax.kind()) {
1270 Some(Self { syntax })
1271 } else {
1272 None
1273 }
1274 }
1275 fn syntax(&self) -> &SyntaxToken {
1276 &self.syntax
1277 }
1278}
1279#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1280pub struct Pipepipe {
1281 pub(crate) syntax: SyntaxToken,
1282}
1283impl std::fmt::Display for Pipepipe {
1284 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1285 std::fmt::Display::fmt(&self.syntax, f)
1286 }
1287}
1288impl AstToken for Pipepipe {
1289 fn can_cast(kind: SyntaxKind) -> bool {
1290 match kind {
1291 PIPEPIPE => true,
1292 _ => false,
1293 }
1294 }
1295 fn cast(syntax: SyntaxToken) -> Option<Self> {
1296 if Self::can_cast(syntax.kind()) {
1297 Some(Self { syntax })
1298 } else {
1299 None
1300 }
1301 }
1302 fn syntax(&self) -> &SyntaxToken {
1303 &self.syntax
1304 }
1305}
1306#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1307pub struct Shl {
1308 pub(crate) syntax: SyntaxToken,
1309}
1310impl std::fmt::Display for Shl {
1311 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1312 std::fmt::Display::fmt(&self.syntax, f)
1313 }
1314}
1315impl AstToken for Shl {
1316 fn can_cast(kind: SyntaxKind) -> bool {
1317 match kind {
1318 SHL => true,
1319 _ => false,
1320 }
1321 }
1322 fn cast(syntax: SyntaxToken) -> Option<Self> {
1323 if Self::can_cast(syntax.kind()) {
1324 Some(Self { syntax })
1325 } else {
1326 None
1327 }
1328 }
1329 fn syntax(&self) -> &SyntaxToken {
1330 &self.syntax
1331 }
1332}
1333#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1334pub struct Shr {
1335 pub(crate) syntax: SyntaxToken,
1336}
1337impl std::fmt::Display for Shr {
1338 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1339 std::fmt::Display::fmt(&self.syntax, f)
1340 }
1341}
1342impl AstToken for Shr {
1343 fn can_cast(kind: SyntaxKind) -> bool {
1344 match kind {
1345 SHR => true,
1346 _ => false,
1347 }
1348 }
1349 fn cast(syntax: SyntaxToken) -> Option<Self> {
1350 if Self::can_cast(syntax.kind()) {
1351 Some(Self { syntax })
1352 } else {
1353 None
1354 }
1355 }
1356 fn syntax(&self) -> &SyntaxToken {
1357 &self.syntax
1358 }
1359}
1360#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1361pub struct Shleq {
1362 pub(crate) syntax: SyntaxToken,
1363}
1364impl std::fmt::Display for Shleq {
1365 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1366 std::fmt::Display::fmt(&self.syntax, f)
1367 }
1368}
1369impl AstToken for Shleq {
1370 fn can_cast(kind: SyntaxKind) -> bool {
1371 match kind {
1372 SHLEQ => true,
1373 _ => false,
1374 }
1375 }
1376 fn cast(syntax: SyntaxToken) -> Option<Self> {
1377 if Self::can_cast(syntax.kind()) {
1378 Some(Self { syntax })
1379 } else {
1380 None
1381 }
1382 }
1383 fn syntax(&self) -> &SyntaxToken {
1384 &self.syntax
1385 }
1386}
1387#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1388pub struct Shreq {
1389 pub(crate) syntax: SyntaxToken,
1390}
1391impl std::fmt::Display for Shreq {
1392 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1393 std::fmt::Display::fmt(&self.syntax, f)
1394 }
1395}
1396impl AstToken for Shreq {
1397 fn can_cast(kind: SyntaxKind) -> bool {
1398 match kind {
1399 SHREQ => true,
1400 _ => false,
1401 }
1402 }
1403 fn cast(syntax: SyntaxToken) -> Option<Self> {
1404 if Self::can_cast(syntax.kind()) {
1405 Some(Self { syntax })
1406 } else {
1407 None
1408 }
1409 }
1410 fn syntax(&self) -> &SyntaxToken {
1411 &self.syntax
1412 }
1413}
1414#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1415pub struct AsKw {
1416 pub(crate) syntax: SyntaxToken,
1417}
1418impl std::fmt::Display for AsKw {
1419 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1420 std::fmt::Display::fmt(&self.syntax, f)
1421 }
1422}
1423impl AstToken for AsKw {
1424 fn can_cast(kind: SyntaxKind) -> bool {
1425 match kind {
1426 AS_KW => true,
1427 _ => false,
1428 }
1429 }
1430 fn cast(syntax: SyntaxToken) -> Option<Self> {
1431 if Self::can_cast(syntax.kind()) {
1432 Some(Self { syntax })
1433 } else {
1434 None
1435 }
1436 }
1437 fn syntax(&self) -> &SyntaxToken {
1438 &self.syntax
1439 }
1440}
1441#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1442pub struct AsyncKw {
1443 pub(crate) syntax: SyntaxToken,
1444}
1445impl std::fmt::Display for AsyncKw {
1446 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1447 std::fmt::Display::fmt(&self.syntax, f)
1448 }
1449}
1450impl AstToken for AsyncKw {
1451 fn can_cast(kind: SyntaxKind) -> bool {
1452 match kind {
1453 ASYNC_KW => true,
1454 _ => false,
1455 }
1456 }
1457 fn cast(syntax: SyntaxToken) -> Option<Self> {
1458 if Self::can_cast(syntax.kind()) {
1459 Some(Self { syntax })
1460 } else {
1461 None
1462 }
1463 }
1464 fn syntax(&self) -> &SyntaxToken {
1465 &self.syntax
1466 }
1467}
1468#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1469pub struct AwaitKw {
1470 pub(crate) syntax: SyntaxToken,
1471}
1472impl std::fmt::Display for AwaitKw {
1473 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1474 std::fmt::Display::fmt(&self.syntax, f)
1475 }
1476}
1477impl AstToken for AwaitKw {
1478 fn can_cast(kind: SyntaxKind) -> bool {
1479 match kind {
1480 AWAIT_KW => true,
1481 _ => false,
1482 }
1483 }
1484 fn cast(syntax: SyntaxToken) -> Option<Self> {
1485 if Self::can_cast(syntax.kind()) {
1486 Some(Self { syntax })
1487 } else {
1488 None
1489 }
1490 }
1491 fn syntax(&self) -> &SyntaxToken {
1492 &self.syntax
1493 }
1494}
1495#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1496pub struct BoxKw {
1497 pub(crate) syntax: SyntaxToken,
1498}
1499impl std::fmt::Display for BoxKw {
1500 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1501 std::fmt::Display::fmt(&self.syntax, f)
1502 }
1503}
1504impl AstToken for BoxKw {
1505 fn can_cast(kind: SyntaxKind) -> bool {
1506 match kind {
1507 BOX_KW => true,
1508 _ => false,
1509 }
1510 }
1511 fn cast(syntax: SyntaxToken) -> Option<Self> {
1512 if Self::can_cast(syntax.kind()) {
1513 Some(Self { syntax })
1514 } else {
1515 None
1516 }
1517 }
1518 fn syntax(&self) -> &SyntaxToken {
1519 &self.syntax
1520 }
1521}
1522#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1523pub struct BreakKw {
1524 pub(crate) syntax: SyntaxToken,
1525}
1526impl std::fmt::Display for BreakKw {
1527 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1528 std::fmt::Display::fmt(&self.syntax, f)
1529 }
1530}
1531impl AstToken for BreakKw {
1532 fn can_cast(kind: SyntaxKind) -> bool {
1533 match kind {
1534 BREAK_KW => true,
1535 _ => false,
1536 }
1537 }
1538 fn cast(syntax: SyntaxToken) -> Option<Self> {
1539 if Self::can_cast(syntax.kind()) {
1540 Some(Self { syntax })
1541 } else {
1542 None
1543 }
1544 }
1545 fn syntax(&self) -> &SyntaxToken {
1546 &self.syntax
1547 }
1548}
1549#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1550pub struct ConstKw {
1551 pub(crate) syntax: SyntaxToken,
1552}
1553impl std::fmt::Display for ConstKw {
1554 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1555 std::fmt::Display::fmt(&self.syntax, f)
1556 }
1557}
1558impl AstToken for ConstKw {
1559 fn can_cast(kind: SyntaxKind) -> bool {
1560 match kind {
1561 CONST_KW => true,
1562 _ => false,
1563 }
1564 }
1565 fn cast(syntax: SyntaxToken) -> Option<Self> {
1566 if Self::can_cast(syntax.kind()) {
1567 Some(Self { syntax })
1568 } else {
1569 None
1570 }
1571 }
1572 fn syntax(&self) -> &SyntaxToken {
1573 &self.syntax
1574 }
1575}
1576#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1577pub struct ContinueKw {
1578 pub(crate) syntax: SyntaxToken,
1579}
1580impl std::fmt::Display for ContinueKw {
1581 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1582 std::fmt::Display::fmt(&self.syntax, f)
1583 }
1584}
1585impl AstToken for ContinueKw {
1586 fn can_cast(kind: SyntaxKind) -> bool {
1587 match kind {
1588 CONTINUE_KW => true,
1589 _ => false,
1590 }
1591 }
1592 fn cast(syntax: SyntaxToken) -> Option<Self> {
1593 if Self::can_cast(syntax.kind()) {
1594 Some(Self { syntax })
1595 } else {
1596 None
1597 }
1598 }
1599 fn syntax(&self) -> &SyntaxToken {
1600 &self.syntax
1601 }
1602}
1603#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1604pub struct CrateKw {
1605 pub(crate) syntax: SyntaxToken,
1606}
1607impl std::fmt::Display for CrateKw {
1608 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1609 std::fmt::Display::fmt(&self.syntax, f)
1610 }
1611}
1612impl AstToken for CrateKw {
1613 fn can_cast(kind: SyntaxKind) -> bool {
1614 match kind {
1615 CRATE_KW => true,
1616 _ => false,
1617 }
1618 }
1619 fn cast(syntax: SyntaxToken) -> Option<Self> {
1620 if Self::can_cast(syntax.kind()) {
1621 Some(Self { syntax })
1622 } else {
1623 None
1624 }
1625 }
1626 fn syntax(&self) -> &SyntaxToken {
1627 &self.syntax
1628 }
1629}
1630#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1631pub struct DynKw {
1632 pub(crate) syntax: SyntaxToken,
1633}
1634impl std::fmt::Display for DynKw {
1635 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1636 std::fmt::Display::fmt(&self.syntax, f)
1637 }
1638}
1639impl AstToken for DynKw {
1640 fn can_cast(kind: SyntaxKind) -> bool {
1641 match kind {
1642 DYN_KW => true,
1643 _ => false,
1644 }
1645 }
1646 fn cast(syntax: SyntaxToken) -> Option<Self> {
1647 if Self::can_cast(syntax.kind()) {
1648 Some(Self { syntax })
1649 } else {
1650 None
1651 }
1652 }
1653 fn syntax(&self) -> &SyntaxToken {
1654 &self.syntax
1655 }
1656}
1657#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1658pub struct ElseKw {
1659 pub(crate) syntax: SyntaxToken,
1660}
1661impl std::fmt::Display for ElseKw {
1662 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1663 std::fmt::Display::fmt(&self.syntax, f)
1664 }
1665}
1666impl AstToken for ElseKw {
1667 fn can_cast(kind: SyntaxKind) -> bool {
1668 match kind {
1669 ELSE_KW => true,
1670 _ => false,
1671 }
1672 }
1673 fn cast(syntax: SyntaxToken) -> Option<Self> {
1674 if Self::can_cast(syntax.kind()) {
1675 Some(Self { syntax })
1676 } else {
1677 None
1678 }
1679 }
1680 fn syntax(&self) -> &SyntaxToken {
1681 &self.syntax
1682 }
1683}
1684#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1685pub struct EnumKw {
1686 pub(crate) syntax: SyntaxToken,
1687}
1688impl std::fmt::Display for EnumKw {
1689 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1690 std::fmt::Display::fmt(&self.syntax, f)
1691 }
1692}
1693impl AstToken for EnumKw {
1694 fn can_cast(kind: SyntaxKind) -> bool {
1695 match kind {
1696 ENUM_KW => true,
1697 _ => false,
1698 }
1699 }
1700 fn cast(syntax: SyntaxToken) -> Option<Self> {
1701 if Self::can_cast(syntax.kind()) {
1702 Some(Self { syntax })
1703 } else {
1704 None
1705 }
1706 }
1707 fn syntax(&self) -> &SyntaxToken {
1708 &self.syntax
1709 }
1710}
1711#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1712pub struct ExternKw {
1713 pub(crate) syntax: SyntaxToken,
1714}
1715impl std::fmt::Display for ExternKw {
1716 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1717 std::fmt::Display::fmt(&self.syntax, f)
1718 }
1719}
1720impl AstToken for ExternKw {
1721 fn can_cast(kind: SyntaxKind) -> bool {
1722 match kind {
1723 EXTERN_KW => true,
1724 _ => false,
1725 }
1726 }
1727 fn cast(syntax: SyntaxToken) -> Option<Self> {
1728 if Self::can_cast(syntax.kind()) {
1729 Some(Self { syntax })
1730 } else {
1731 None
1732 }
1733 }
1734 fn syntax(&self) -> &SyntaxToken {
1735 &self.syntax
1736 }
1737}
1738#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1739pub struct FalseKw {
1740 pub(crate) syntax: SyntaxToken,
1741}
1742impl std::fmt::Display for FalseKw {
1743 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1744 std::fmt::Display::fmt(&self.syntax, f)
1745 }
1746}
1747impl AstToken for FalseKw {
1748 fn can_cast(kind: SyntaxKind) -> bool {
1749 match kind {
1750 FALSE_KW => true,
1751 _ => false,
1752 }
1753 }
1754 fn cast(syntax: SyntaxToken) -> Option<Self> {
1755 if Self::can_cast(syntax.kind()) {
1756 Some(Self { syntax })
1757 } else {
1758 None
1759 }
1760 }
1761 fn syntax(&self) -> &SyntaxToken {
1762 &self.syntax
1763 }
1764}
1765#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1766pub struct FnKw {
1767 pub(crate) syntax: SyntaxToken,
1768}
1769impl std::fmt::Display for FnKw {
1770 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1771 std::fmt::Display::fmt(&self.syntax, f)
1772 }
1773}
1774impl AstToken for FnKw {
1775 fn can_cast(kind: SyntaxKind) -> bool {
1776 match kind {
1777 FN_KW => true,
1778 _ => false,
1779 }
1780 }
1781 fn cast(syntax: SyntaxToken) -> Option<Self> {
1782 if Self::can_cast(syntax.kind()) {
1783 Some(Self { syntax })
1784 } else {
1785 None
1786 }
1787 }
1788 fn syntax(&self) -> &SyntaxToken {
1789 &self.syntax
1790 }
1791}
1792#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1793pub struct ForKw {
1794 pub(crate) syntax: SyntaxToken,
1795}
1796impl std::fmt::Display for ForKw {
1797 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1798 std::fmt::Display::fmt(&self.syntax, f)
1799 }
1800}
1801impl AstToken for ForKw {
1802 fn can_cast(kind: SyntaxKind) -> bool {
1803 match kind {
1804 FOR_KW => true,
1805 _ => false,
1806 }
1807 }
1808 fn cast(syntax: SyntaxToken) -> Option<Self> {
1809 if Self::can_cast(syntax.kind()) {
1810 Some(Self { syntax })
1811 } else {
1812 None
1813 }
1814 }
1815 fn syntax(&self) -> &SyntaxToken {
1816 &self.syntax
1817 }
1818}
1819#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1820pub struct IfKw {
1821 pub(crate) syntax: SyntaxToken,
1822}
1823impl std::fmt::Display for IfKw {
1824 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1825 std::fmt::Display::fmt(&self.syntax, f)
1826 }
1827}
1828impl AstToken for IfKw {
1829 fn can_cast(kind: SyntaxKind) -> bool {
1830 match kind {
1831 IF_KW => true,
1832 _ => false,
1833 }
1834 }
1835 fn cast(syntax: SyntaxToken) -> Option<Self> {
1836 if Self::can_cast(syntax.kind()) {
1837 Some(Self { syntax })
1838 } else {
1839 None
1840 }
1841 }
1842 fn syntax(&self) -> &SyntaxToken {
1843 &self.syntax
1844 }
1845}
1846#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1847pub struct ImplKw {
1848 pub(crate) syntax: SyntaxToken,
1849}
1850impl std::fmt::Display for ImplKw {
1851 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1852 std::fmt::Display::fmt(&self.syntax, f)
1853 }
1854}
1855impl AstToken for ImplKw {
1856 fn can_cast(kind: SyntaxKind) -> bool {
1857 match kind {
1858 IMPL_KW => true,
1859 _ => false,
1860 }
1861 }
1862 fn cast(syntax: SyntaxToken) -> Option<Self> {
1863 if Self::can_cast(syntax.kind()) {
1864 Some(Self { syntax })
1865 } else {
1866 None
1867 }
1868 }
1869 fn syntax(&self) -> &SyntaxToken {
1870 &self.syntax
1871 }
1872}
1873#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1874pub struct InKw {
1875 pub(crate) syntax: SyntaxToken,
1876}
1877impl std::fmt::Display for InKw {
1878 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1879 std::fmt::Display::fmt(&self.syntax, f)
1880 }
1881}
1882impl AstToken for InKw {
1883 fn can_cast(kind: SyntaxKind) -> bool {
1884 match kind {
1885 IN_KW => true,
1886 _ => false,
1887 }
1888 }
1889 fn cast(syntax: SyntaxToken) -> Option<Self> {
1890 if Self::can_cast(syntax.kind()) {
1891 Some(Self { syntax })
1892 } else {
1893 None
1894 }
1895 }
1896 fn syntax(&self) -> &SyntaxToken {
1897 &self.syntax
1898 }
1899}
1900#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1901pub struct LetKw {
1902 pub(crate) syntax: SyntaxToken,
1903}
1904impl std::fmt::Display for LetKw {
1905 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1906 std::fmt::Display::fmt(&self.syntax, f)
1907 }
1908}
1909impl AstToken for LetKw {
1910 fn can_cast(kind: SyntaxKind) -> bool {
1911 match kind {
1912 LET_KW => true,
1913 _ => false,
1914 }
1915 }
1916 fn cast(syntax: SyntaxToken) -> Option<Self> {
1917 if Self::can_cast(syntax.kind()) {
1918 Some(Self { syntax })
1919 } else {
1920 None
1921 }
1922 }
1923 fn syntax(&self) -> &SyntaxToken {
1924 &self.syntax
1925 }
1926}
1927#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1928pub struct LoopKw {
1929 pub(crate) syntax: SyntaxToken,
1930}
1931impl std::fmt::Display for LoopKw {
1932 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1933 std::fmt::Display::fmt(&self.syntax, f)
1934 }
1935}
1936impl AstToken for LoopKw {
1937 fn can_cast(kind: SyntaxKind) -> bool {
1938 match kind {
1939 LOOP_KW => true,
1940 _ => false,
1941 }
1942 }
1943 fn cast(syntax: SyntaxToken) -> Option<Self> {
1944 if Self::can_cast(syntax.kind()) {
1945 Some(Self { syntax })
1946 } else {
1947 None
1948 }
1949 }
1950 fn syntax(&self) -> &SyntaxToken {
1951 &self.syntax
1952 }
1953}
1954#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1955pub struct MacroKw {
1956 pub(crate) syntax: SyntaxToken,
1957}
1958impl std::fmt::Display for MacroKw {
1959 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1960 std::fmt::Display::fmt(&self.syntax, f)
1961 }
1962}
1963impl AstToken for MacroKw {
1964 fn can_cast(kind: SyntaxKind) -> bool {
1965 match kind {
1966 MACRO_KW => true,
1967 _ => false,
1968 }
1969 }
1970 fn cast(syntax: SyntaxToken) -> Option<Self> {
1971 if Self::can_cast(syntax.kind()) {
1972 Some(Self { syntax })
1973 } else {
1974 None
1975 }
1976 }
1977 fn syntax(&self) -> &SyntaxToken {
1978 &self.syntax
1979 }
1980}
1981#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1982pub struct MatchKw {
1983 pub(crate) syntax: SyntaxToken,
1984}
1985impl std::fmt::Display for MatchKw {
1986 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1987 std::fmt::Display::fmt(&self.syntax, f)
1988 }
1989}
1990impl AstToken for MatchKw {
1991 fn can_cast(kind: SyntaxKind) -> bool {
1992 match kind {
1993 MATCH_KW => true,
1994 _ => false,
1995 }
1996 }
1997 fn cast(syntax: SyntaxToken) -> Option<Self> {
1998 if Self::can_cast(syntax.kind()) {
1999 Some(Self { syntax })
2000 } else {
2001 None
2002 }
2003 }
2004 fn syntax(&self) -> &SyntaxToken {
2005 &self.syntax
2006 }
2007}
2008#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2009pub struct ModKw {
2010 pub(crate) syntax: SyntaxToken,
2011}
2012impl std::fmt::Display for ModKw {
2013 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2014 std::fmt::Display::fmt(&self.syntax, f)
2015 }
2016}
2017impl AstToken for ModKw {
2018 fn can_cast(kind: SyntaxKind) -> bool {
2019 match kind {
2020 MOD_KW => true,
2021 _ => false,
2022 }
2023 }
2024 fn cast(syntax: SyntaxToken) -> Option<Self> {
2025 if Self::can_cast(syntax.kind()) {
2026 Some(Self { syntax })
2027 } else {
2028 None
2029 }
2030 }
2031 fn syntax(&self) -> &SyntaxToken {
2032 &self.syntax
2033 }
2034}
2035#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2036pub struct MoveKw {
2037 pub(crate) syntax: SyntaxToken,
2038}
2039impl std::fmt::Display for MoveKw {
2040 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2041 std::fmt::Display::fmt(&self.syntax, f)
2042 }
2043}
2044impl AstToken for MoveKw {
2045 fn can_cast(kind: SyntaxKind) -> bool {
2046 match kind {
2047 MOVE_KW => true,
2048 _ => false,
2049 }
2050 }
2051 fn cast(syntax: SyntaxToken) -> Option<Self> {
2052 if Self::can_cast(syntax.kind()) {
2053 Some(Self { syntax })
2054 } else {
2055 None
2056 }
2057 }
2058 fn syntax(&self) -> &SyntaxToken {
2059 &self.syntax
2060 }
2061}
2062#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2063pub struct MutKw {
2064 pub(crate) syntax: SyntaxToken,
2065}
2066impl std::fmt::Display for MutKw {
2067 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2068 std::fmt::Display::fmt(&self.syntax, f)
2069 }
2070}
2071impl AstToken for MutKw {
2072 fn can_cast(kind: SyntaxKind) -> bool {
2073 match kind {
2074 MUT_KW => true,
2075 _ => false,
2076 }
2077 }
2078 fn cast(syntax: SyntaxToken) -> Option<Self> {
2079 if Self::can_cast(syntax.kind()) {
2080 Some(Self { syntax })
2081 } else {
2082 None
2083 }
2084 }
2085 fn syntax(&self) -> &SyntaxToken {
2086 &self.syntax
2087 }
2088}
2089#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2090pub struct PubKw {
2091 pub(crate) syntax: SyntaxToken,
2092}
2093impl std::fmt::Display for PubKw {
2094 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2095 std::fmt::Display::fmt(&self.syntax, f)
2096 }
2097}
2098impl AstToken for PubKw {
2099 fn can_cast(kind: SyntaxKind) -> bool {
2100 match kind {
2101 PUB_KW => true,
2102 _ => false,
2103 }
2104 }
2105 fn cast(syntax: SyntaxToken) -> Option<Self> {
2106 if Self::can_cast(syntax.kind()) {
2107 Some(Self { syntax })
2108 } else {
2109 None
2110 }
2111 }
2112 fn syntax(&self) -> &SyntaxToken {
2113 &self.syntax
2114 }
2115}
2116#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2117pub struct RefKw {
2118 pub(crate) syntax: SyntaxToken,
2119}
2120impl std::fmt::Display for RefKw {
2121 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2122 std::fmt::Display::fmt(&self.syntax, f)
2123 }
2124}
2125impl AstToken for RefKw {
2126 fn can_cast(kind: SyntaxKind) -> bool {
2127 match kind {
2128 REF_KW => true,
2129 _ => false,
2130 }
2131 }
2132 fn cast(syntax: SyntaxToken) -> Option<Self> {
2133 if Self::can_cast(syntax.kind()) {
2134 Some(Self { syntax })
2135 } else {
2136 None
2137 }
2138 }
2139 fn syntax(&self) -> &SyntaxToken {
2140 &self.syntax
2141 }
2142}
2143#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2144pub struct ReturnKw {
2145 pub(crate) syntax: SyntaxToken,
2146}
2147impl std::fmt::Display for ReturnKw {
2148 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2149 std::fmt::Display::fmt(&self.syntax, f)
2150 }
2151}
2152impl AstToken for ReturnKw {
2153 fn can_cast(kind: SyntaxKind) -> bool {
2154 match kind {
2155 RETURN_KW => true,
2156 _ => false,
2157 }
2158 }
2159 fn cast(syntax: SyntaxToken) -> Option<Self> {
2160 if Self::can_cast(syntax.kind()) {
2161 Some(Self { syntax })
2162 } else {
2163 None
2164 }
2165 }
2166 fn syntax(&self) -> &SyntaxToken {
2167 &self.syntax
2168 }
2169}
2170#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2171pub struct SelfKw {
2172 pub(crate) syntax: SyntaxToken,
2173}
2174impl std::fmt::Display for SelfKw {
2175 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2176 std::fmt::Display::fmt(&self.syntax, f)
2177 }
2178}
2179impl AstToken for SelfKw {
2180 fn can_cast(kind: SyntaxKind) -> bool {
2181 match kind {
2182 SELF_KW => true,
2183 _ => false,
2184 }
2185 }
2186 fn cast(syntax: SyntaxToken) -> Option<Self> {
2187 if Self::can_cast(syntax.kind()) {
2188 Some(Self { syntax })
2189 } else {
2190 None
2191 }
2192 }
2193 fn syntax(&self) -> &SyntaxToken {
2194 &self.syntax
2195 }
2196}
2197#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2198pub struct StaticKw {
2199 pub(crate) syntax: SyntaxToken,
2200}
2201impl std::fmt::Display for StaticKw {
2202 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2203 std::fmt::Display::fmt(&self.syntax, f)
2204 }
2205}
2206impl AstToken for StaticKw {
2207 fn can_cast(kind: SyntaxKind) -> bool {
2208 match kind {
2209 STATIC_KW => true,
2210 _ => false,
2211 }
2212 }
2213 fn cast(syntax: SyntaxToken) -> Option<Self> {
2214 if Self::can_cast(syntax.kind()) {
2215 Some(Self { syntax })
2216 } else {
2217 None
2218 }
2219 }
2220 fn syntax(&self) -> &SyntaxToken {
2221 &self.syntax
2222 }
2223}
2224#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2225pub struct StructKw {
2226 pub(crate) syntax: SyntaxToken,
2227}
2228impl std::fmt::Display for StructKw {
2229 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2230 std::fmt::Display::fmt(&self.syntax, f)
2231 }
2232}
2233impl AstToken for StructKw {
2234 fn can_cast(kind: SyntaxKind) -> bool {
2235 match kind {
2236 STRUCT_KW => true,
2237 _ => false,
2238 }
2239 }
2240 fn cast(syntax: SyntaxToken) -> Option<Self> {
2241 if Self::can_cast(syntax.kind()) {
2242 Some(Self { syntax })
2243 } else {
2244 None
2245 }
2246 }
2247 fn syntax(&self) -> &SyntaxToken {
2248 &self.syntax
2249 }
2250}
2251#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2252pub struct SuperKw {
2253 pub(crate) syntax: SyntaxToken,
2254}
2255impl std::fmt::Display for SuperKw {
2256 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2257 std::fmt::Display::fmt(&self.syntax, f)
2258 }
2259}
2260impl AstToken for SuperKw {
2261 fn can_cast(kind: SyntaxKind) -> bool {
2262 match kind {
2263 SUPER_KW => true,
2264 _ => false,
2265 }
2266 }
2267 fn cast(syntax: SyntaxToken) -> Option<Self> {
2268 if Self::can_cast(syntax.kind()) {
2269 Some(Self { syntax })
2270 } else {
2271 None
2272 }
2273 }
2274 fn syntax(&self) -> &SyntaxToken {
2275 &self.syntax
2276 }
2277}
2278#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2279pub struct TraitKw {
2280 pub(crate) syntax: SyntaxToken,
2281}
2282impl std::fmt::Display for TraitKw {
2283 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2284 std::fmt::Display::fmt(&self.syntax, f)
2285 }
2286}
2287impl AstToken for TraitKw {
2288 fn can_cast(kind: SyntaxKind) -> bool {
2289 match kind {
2290 TRAIT_KW => true,
2291 _ => false,
2292 }
2293 }
2294 fn cast(syntax: SyntaxToken) -> Option<Self> {
2295 if Self::can_cast(syntax.kind()) {
2296 Some(Self { syntax })
2297 } else {
2298 None
2299 }
2300 }
2301 fn syntax(&self) -> &SyntaxToken {
2302 &self.syntax
2303 }
2304}
2305#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2306pub struct TrueKw {
2307 pub(crate) syntax: SyntaxToken,
2308}
2309impl std::fmt::Display for TrueKw {
2310 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2311 std::fmt::Display::fmt(&self.syntax, f)
2312 }
2313}
2314impl AstToken for TrueKw {
2315 fn can_cast(kind: SyntaxKind) -> bool {
2316 match kind {
2317 TRUE_KW => true,
2318 _ => false,
2319 }
2320 }
2321 fn cast(syntax: SyntaxToken) -> Option<Self> {
2322 if Self::can_cast(syntax.kind()) {
2323 Some(Self { syntax })
2324 } else {
2325 None
2326 }
2327 }
2328 fn syntax(&self) -> &SyntaxToken {
2329 &self.syntax
2330 }
2331}
2332#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2333pub struct TryKw {
2334 pub(crate) syntax: SyntaxToken,
2335}
2336impl std::fmt::Display for TryKw {
2337 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2338 std::fmt::Display::fmt(&self.syntax, f)
2339 }
2340}
2341impl AstToken for TryKw {
2342 fn can_cast(kind: SyntaxKind) -> bool {
2343 match kind {
2344 TRY_KW => true,
2345 _ => false,
2346 }
2347 }
2348 fn cast(syntax: SyntaxToken) -> Option<Self> {
2349 if Self::can_cast(syntax.kind()) {
2350 Some(Self { syntax })
2351 } else {
2352 None
2353 }
2354 }
2355 fn syntax(&self) -> &SyntaxToken {
2356 &self.syntax
2357 }
2358}
2359#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2360pub struct TypeKw {
2361 pub(crate) syntax: SyntaxToken,
2362}
2363impl std::fmt::Display for TypeKw {
2364 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2365 std::fmt::Display::fmt(&self.syntax, f)
2366 }
2367}
2368impl AstToken for TypeKw {
2369 fn can_cast(kind: SyntaxKind) -> bool {
2370 match kind {
2371 TYPE_KW => true,
2372 _ => false,
2373 }
2374 }
2375 fn cast(syntax: SyntaxToken) -> Option<Self> {
2376 if Self::can_cast(syntax.kind()) {
2377 Some(Self { syntax })
2378 } else {
2379 None
2380 }
2381 }
2382 fn syntax(&self) -> &SyntaxToken {
2383 &self.syntax
2384 }
2385}
2386#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2387pub struct UnsafeKw {
2388 pub(crate) syntax: SyntaxToken,
2389}
2390impl std::fmt::Display for UnsafeKw {
2391 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2392 std::fmt::Display::fmt(&self.syntax, f)
2393 }
2394}
2395impl AstToken for UnsafeKw {
2396 fn can_cast(kind: SyntaxKind) -> bool {
2397 match kind {
2398 UNSAFE_KW => true,
2399 _ => false,
2400 }
2401 }
2402 fn cast(syntax: SyntaxToken) -> Option<Self> {
2403 if Self::can_cast(syntax.kind()) {
2404 Some(Self { syntax })
2405 } else {
2406 None
2407 }
2408 }
2409 fn syntax(&self) -> &SyntaxToken {
2410 &self.syntax
2411 }
2412}
2413#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2414pub struct UseKw {
2415 pub(crate) syntax: SyntaxToken,
2416}
2417impl std::fmt::Display for UseKw {
2418 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2419 std::fmt::Display::fmt(&self.syntax, f)
2420 }
2421}
2422impl AstToken for UseKw {
2423 fn can_cast(kind: SyntaxKind) -> bool {
2424 match kind {
2425 USE_KW => true,
2426 _ => false,
2427 }
2428 }
2429 fn cast(syntax: SyntaxToken) -> Option<Self> {
2430 if Self::can_cast(syntax.kind()) {
2431 Some(Self { syntax })
2432 } else {
2433 None
2434 }
2435 }
2436 fn syntax(&self) -> &SyntaxToken {
2437 &self.syntax
2438 }
2439}
2440#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2441pub struct WhereKw {
2442 pub(crate) syntax: SyntaxToken,
2443}
2444impl std::fmt::Display for WhereKw {
2445 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2446 std::fmt::Display::fmt(&self.syntax, f)
2447 }
2448}
2449impl AstToken for WhereKw {
2450 fn can_cast(kind: SyntaxKind) -> bool {
2451 match kind {
2452 WHERE_KW => true,
2453 _ => false,
2454 }
2455 }
2456 fn cast(syntax: SyntaxToken) -> Option<Self> {
2457 if Self::can_cast(syntax.kind()) {
2458 Some(Self { syntax })
2459 } else {
2460 None
2461 }
2462 }
2463 fn syntax(&self) -> &SyntaxToken {
2464 &self.syntax
2465 }
2466}
2467#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2468pub struct WhileKw {
2469 pub(crate) syntax: SyntaxToken,
2470}
2471impl std::fmt::Display for WhileKw {
2472 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2473 std::fmt::Display::fmt(&self.syntax, f)
2474 }
2475}
2476impl AstToken for WhileKw {
2477 fn can_cast(kind: SyntaxKind) -> bool {
2478 match kind {
2479 WHILE_KW => true,
2480 _ => false,
2481 }
2482 }
2483 fn cast(syntax: SyntaxToken) -> Option<Self> {
2484 if Self::can_cast(syntax.kind()) {
2485 Some(Self { syntax })
2486 } else {
2487 None
2488 }
2489 }
2490 fn syntax(&self) -> &SyntaxToken {
2491 &self.syntax
2492 }
2493}
2494#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2495pub struct AutoKw {
2496 pub(crate) syntax: SyntaxToken,
2497}
2498impl std::fmt::Display for AutoKw {
2499 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2500 std::fmt::Display::fmt(&self.syntax, f)
2501 }
2502}
2503impl AstToken for AutoKw {
2504 fn can_cast(kind: SyntaxKind) -> bool {
2505 match kind {
2506 AUTO_KW => true,
2507 _ => false,
2508 }
2509 }
2510 fn cast(syntax: SyntaxToken) -> Option<Self> {
2511 if Self::can_cast(syntax.kind()) {
2512 Some(Self { syntax })
2513 } else {
2514 None
2515 }
2516 }
2517 fn syntax(&self) -> &SyntaxToken {
2518 &self.syntax
2519 }
2520}
2521#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2522pub struct DefaultKw {
2523 pub(crate) syntax: SyntaxToken,
2524}
2525impl std::fmt::Display for DefaultKw {
2526 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2527 std::fmt::Display::fmt(&self.syntax, f)
2528 }
2529}
2530impl AstToken for DefaultKw {
2531 fn can_cast(kind: SyntaxKind) -> bool {
2532 match kind {
2533 DEFAULT_KW => true,
2534 _ => false,
2535 }
2536 }
2537 fn cast(syntax: SyntaxToken) -> Option<Self> {
2538 if Self::can_cast(syntax.kind()) {
2539 Some(Self { syntax })
2540 } else {
2541 None
2542 }
2543 }
2544 fn syntax(&self) -> &SyntaxToken {
2545 &self.syntax
2546 }
2547}
2548#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2549pub struct ExistentialKw {
2550 pub(crate) syntax: SyntaxToken,
2551}
2552impl std::fmt::Display for ExistentialKw {
2553 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2554 std::fmt::Display::fmt(&self.syntax, f)
2555 }
2556}
2557impl AstToken for ExistentialKw {
2558 fn can_cast(kind: SyntaxKind) -> bool {
2559 match kind {
2560 EXISTENTIAL_KW => true,
2561 _ => false,
2562 }
2563 }
2564 fn cast(syntax: SyntaxToken) -> Option<Self> {
2565 if Self::can_cast(syntax.kind()) {
2566 Some(Self { syntax })
2567 } else {
2568 None
2569 }
2570 }
2571 fn syntax(&self) -> &SyntaxToken {
2572 &self.syntax
2573 }
2574}
2575#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2576pub struct UnionKw {
2577 pub(crate) syntax: SyntaxToken,
2578}
2579impl std::fmt::Display for UnionKw {
2580 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2581 std::fmt::Display::fmt(&self.syntax, f)
2582 }
2583}
2584impl AstToken for UnionKw {
2585 fn can_cast(kind: SyntaxKind) -> bool {
2586 match kind {
2587 UNION_KW => true,
2588 _ => false,
2589 }
2590 }
2591 fn cast(syntax: SyntaxToken) -> Option<Self> {
2592 if Self::can_cast(syntax.kind()) {
2593 Some(Self { syntax })
2594 } else {
2595 None
2596 }
2597 }
2598 fn syntax(&self) -> &SyntaxToken {
2599 &self.syntax
2600 }
2601}
2602#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2603pub struct IntNumber {
2604 pub(crate) syntax: SyntaxToken,
2605}
2606impl std::fmt::Display for IntNumber {
2607 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2608 std::fmt::Display::fmt(&self.syntax, f)
2609 }
2610}
2611impl AstToken for IntNumber {
2612 fn can_cast(kind: SyntaxKind) -> bool {
2613 match kind {
2614 INT_NUMBER => true,
2615 _ => false,
2616 }
2617 }
2618 fn cast(syntax: SyntaxToken) -> Option<Self> {
2619 if Self::can_cast(syntax.kind()) {
2620 Some(Self { syntax })
2621 } else {
2622 None
2623 }
2624 }
2625 fn syntax(&self) -> &SyntaxToken {
2626 &self.syntax
2627 }
2628}
2629#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2630pub struct FloatNumber {
2631 pub(crate) syntax: SyntaxToken,
2632}
2633impl std::fmt::Display for FloatNumber {
2634 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2635 std::fmt::Display::fmt(&self.syntax, f)
2636 }
2637}
2638impl AstToken for FloatNumber {
2639 fn can_cast(kind: SyntaxKind) -> bool {
2640 match kind {
2641 FLOAT_NUMBER => true,
2642 _ => false,
2643 }
2644 }
2645 fn cast(syntax: SyntaxToken) -> Option<Self> {
2646 if Self::can_cast(syntax.kind()) {
2647 Some(Self { syntax })
2648 } else {
2649 None
2650 }
2651 }
2652 fn syntax(&self) -> &SyntaxToken {
2653 &self.syntax
2654 }
2655}
2656#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2657pub struct Char {
2658 pub(crate) syntax: SyntaxToken,
2659}
2660impl std::fmt::Display for Char {
2661 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2662 std::fmt::Display::fmt(&self.syntax, f)
2663 }
2664}
2665impl AstToken for Char {
2666 fn can_cast(kind: SyntaxKind) -> bool {
2667 match kind {
2668 CHAR => true,
2669 _ => false,
2670 }
2671 }
2672 fn cast(syntax: SyntaxToken) -> Option<Self> {
2673 if Self::can_cast(syntax.kind()) {
2674 Some(Self { syntax })
2675 } else {
2676 None
2677 }
2678 }
2679 fn syntax(&self) -> &SyntaxToken {
2680 &self.syntax
2681 }
2682}
2683#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2684pub struct Byte {
2685 pub(crate) syntax: SyntaxToken,
2686}
2687impl std::fmt::Display for Byte {
2688 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2689 std::fmt::Display::fmt(&self.syntax, f)
2690 }
2691}
2692impl AstToken for Byte {
2693 fn can_cast(kind: SyntaxKind) -> bool {
2694 match kind {
2695 BYTE => true,
2696 _ => false,
2697 }
2698 }
2699 fn cast(syntax: SyntaxToken) -> Option<Self> {
2700 if Self::can_cast(syntax.kind()) {
2701 Some(Self { syntax })
2702 } else {
2703 None
2704 }
2705 }
2706 fn syntax(&self) -> &SyntaxToken {
2707 &self.syntax
2708 }
2709}
2710#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2711pub struct String {
2712 pub(crate) syntax: SyntaxToken,
2713}
2714impl std::fmt::Display for String {
2715 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2716 std::fmt::Display::fmt(&self.syntax, f)
2717 }
2718}
2719impl AstToken for String {
2720 fn can_cast(kind: SyntaxKind) -> bool {
2721 match kind {
2722 STRING => true,
2723 _ => false,
2724 }
2725 }
2726 fn cast(syntax: SyntaxToken) -> Option<Self> {
2727 if Self::can_cast(syntax.kind()) {
2728 Some(Self { syntax })
2729 } else {
2730 None
2731 }
2732 }
2733 fn syntax(&self) -> &SyntaxToken {
2734 &self.syntax
2735 }
2736}
2737#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2738pub struct RawString {
2739 pub(crate) syntax: SyntaxToken,
2740}
2741impl std::fmt::Display for RawString {
2742 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2743 std::fmt::Display::fmt(&self.syntax, f)
2744 }
2745}
2746impl AstToken for RawString {
2747 fn can_cast(kind: SyntaxKind) -> bool {
2748 match kind {
2749 RAW_STRING => true,
2750 _ => false,
2751 }
2752 }
2753 fn cast(syntax: SyntaxToken) -> Option<Self> {
2754 if Self::can_cast(syntax.kind()) {
2755 Some(Self { syntax })
2756 } else {
2757 None
2758 }
2759 }
2760 fn syntax(&self) -> &SyntaxToken {
2761 &self.syntax
2762 }
2763}
2764#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2765pub struct ByteString {
2766 pub(crate) syntax: SyntaxToken,
2767}
2768impl std::fmt::Display for ByteString {
2769 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2770 std::fmt::Display::fmt(&self.syntax, f)
2771 }
2772}
2773impl AstToken for ByteString {
2774 fn can_cast(kind: SyntaxKind) -> bool {
2775 match kind {
2776 BYTE_STRING => true,
2777 _ => false,
2778 }
2779 }
2780 fn cast(syntax: SyntaxToken) -> Option<Self> {
2781 if Self::can_cast(syntax.kind()) {
2782 Some(Self { syntax })
2783 } else {
2784 None
2785 }
2786 }
2787 fn syntax(&self) -> &SyntaxToken {
2788 &self.syntax
2789 }
2790}
2791#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2792pub struct RawByteString {
2793 pub(crate) syntax: SyntaxToken,
2794}
2795impl std::fmt::Display for RawByteString {
2796 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2797 std::fmt::Display::fmt(&self.syntax, f)
2798 }
2799}
2800impl AstToken for RawByteString {
2801 fn can_cast(kind: SyntaxKind) -> bool {
2802 match kind {
2803 RAW_BYTE_STRING => true,
2804 _ => false,
2805 }
2806 }
2807 fn cast(syntax: SyntaxToken) -> Option<Self> {
2808 if Self::can_cast(syntax.kind()) {
2809 Some(Self { syntax })
2810 } else {
2811 None
2812 }
2813 }
2814 fn syntax(&self) -> &SyntaxToken {
2815 &self.syntax
2816 }
2817}
2818#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2819pub struct Error {
2820 pub(crate) syntax: SyntaxToken,
2821}
2822impl std::fmt::Display for Error {
2823 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2824 std::fmt::Display::fmt(&self.syntax, f)
2825 }
2826}
2827impl AstToken for Error {
2828 fn can_cast(kind: SyntaxKind) -> bool {
2829 match kind {
2830 ERROR => true,
2831 _ => false,
2832 }
2833 }
2834 fn cast(syntax: SyntaxToken) -> Option<Self> {
2835 if Self::can_cast(syntax.kind()) {
2836 Some(Self { syntax })
2837 } else {
2838 None
2839 }
2840 }
2841 fn syntax(&self) -> &SyntaxToken {
2842 &self.syntax
2843 }
2844}
2845#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2846pub struct Ident {
2847 pub(crate) syntax: SyntaxToken,
2848}
2849impl std::fmt::Display for Ident {
2850 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2851 std::fmt::Display::fmt(&self.syntax, f)
2852 }
2853}
2854impl AstToken for Ident {
2855 fn can_cast(kind: SyntaxKind) -> bool {
2856 match kind {
2857 IDENT => true,
2858 _ => false,
2859 }
2860 }
2861 fn cast(syntax: SyntaxToken) -> Option<Self> {
2862 if Self::can_cast(syntax.kind()) {
2863 Some(Self { syntax })
2864 } else {
2865 None
2866 }
2867 }
2868 fn syntax(&self) -> &SyntaxToken {
2869 &self.syntax
2870 }
2871}
2872#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2873pub struct Whitespace {
2874 pub(crate) syntax: SyntaxToken,
2875}
2876impl std::fmt::Display for Whitespace {
2877 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2878 std::fmt::Display::fmt(&self.syntax, f)
2879 }
2880}
2881impl AstToken for Whitespace {
2882 fn can_cast(kind: SyntaxKind) -> bool {
2883 match kind {
2884 WHITESPACE => true,
2885 _ => false,
2886 }
2887 }
2888 fn cast(syntax: SyntaxToken) -> Option<Self> {
2889 if Self::can_cast(syntax.kind()) {
2890 Some(Self { syntax })
2891 } else {
2892 None
2893 }
2894 }
2895 fn syntax(&self) -> &SyntaxToken {
2896 &self.syntax
2897 }
2898}
2899#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2900pub struct Lifetime {
2901 pub(crate) syntax: SyntaxToken,
2902}
2903impl std::fmt::Display for Lifetime {
2904 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2905 std::fmt::Display::fmt(&self.syntax, f)
2906 }
2907}
2908impl AstToken for Lifetime {
2909 fn can_cast(kind: SyntaxKind) -> bool {
2910 match kind {
2911 LIFETIME => true,
2912 _ => false,
2913 }
2914 }
2915 fn cast(syntax: SyntaxToken) -> Option<Self> {
2916 if Self::can_cast(syntax.kind()) {
2917 Some(Self { syntax })
2918 } else {
2919 None
2920 }
2921 }
2922 fn syntax(&self) -> &SyntaxToken {
2923 &self.syntax
2924 }
2925}
2926#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2927pub struct Comment {
2928 pub(crate) syntax: SyntaxToken,
2929}
2930impl std::fmt::Display for Comment {
2931 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2932 std::fmt::Display::fmt(&self.syntax, f)
2933 }
2934}
2935impl AstToken for Comment {
2936 fn can_cast(kind: SyntaxKind) -> bool {
2937 match kind {
2938 COMMENT => true,
2939 _ => false,
2940 }
2941 }
2942 fn cast(syntax: SyntaxToken) -> Option<Self> {
2943 if Self::can_cast(syntax.kind()) {
2944 Some(Self { syntax })
2945 } else {
2946 None
2947 }
2948 }
2949 fn syntax(&self) -> &SyntaxToken {
2950 &self.syntax
2951 }
2952}
2953#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2954pub struct Shebang {
2955 pub(crate) syntax: SyntaxToken,
2956}
2957impl std::fmt::Display for Shebang {
2958 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2959 std::fmt::Display::fmt(&self.syntax, f)
2960 }
2961}
2962impl AstToken for Shebang {
2963 fn can_cast(kind: SyntaxKind) -> bool {
2964 match kind {
2965 SHEBANG => true,
2966 _ => false,
2967 }
2968 }
2969 fn cast(syntax: SyntaxToken) -> Option<Self> {
2970 if Self::can_cast(syntax.kind()) {
2971 Some(Self { syntax })
2972 } else {
2973 None
2974 }
2975 }
2976 fn syntax(&self) -> &SyntaxToken {
2977 &self.syntax
2978 }
2979}
2980#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2981pub struct LDollar {
2982 pub(crate) syntax: SyntaxToken,
2983}
2984impl std::fmt::Display for LDollar {
2985 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2986 std::fmt::Display::fmt(&self.syntax, f)
2987 }
2988}
2989impl AstToken for LDollar {
2990 fn can_cast(kind: SyntaxKind) -> bool {
2991 match kind {
2992 L_DOLLAR => true,
2993 _ => false,
2994 }
2995 }
2996 fn cast(syntax: SyntaxToken) -> Option<Self> {
2997 if Self::can_cast(syntax.kind()) {
2998 Some(Self { syntax })
2999 } else {
3000 None
3001 }
3002 }
3003 fn syntax(&self) -> &SyntaxToken {
3004 &self.syntax
3005 }
3006}
3007#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3008pub struct RDollar {
3009 pub(crate) syntax: SyntaxToken,
3010}
3011impl std::fmt::Display for RDollar {
3012 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3013 std::fmt::Display::fmt(&self.syntax, f)
3014 }
3015}
3016impl AstToken for RDollar {
3017 fn can_cast(kind: SyntaxKind) -> bool {
3018 match kind {
3019 R_DOLLAR => true,
3020 _ => false,
3021 }
3022 }
3023 fn cast(syntax: SyntaxToken) -> Option<Self> {
3024 if Self::can_cast(syntax.kind()) {
3025 Some(Self { syntax })
3026 } else {
3027 None
3028 }
3029 }
3030 fn syntax(&self) -> &SyntaxToken {
3031 &self.syntax
3032 }
3033}
3034#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3035pub struct SourceFile {
3036 pub(crate) syntax: SyntaxNode,
3037}
3038impl std::fmt::Display for SourceFile {
3039 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3040 std::fmt::Display::fmt(self.syntax(), f)
3041 }
3042}
3043impl AstNode for SourceFile {
3044 fn can_cast(kind: SyntaxKind) -> bool {
3045 match kind {
3046 SOURCE_FILE => true,
3047 _ => false,
3048 }
3049 }
3050 fn cast(syntax: SyntaxNode) -> Option<Self> {
3051 if Self::can_cast(syntax.kind()) {
3052 Some(Self { syntax })
3053 } else {
3054 None
3055 }
3056 }
3057 fn syntax(&self) -> &SyntaxNode {
3058 &self.syntax
3059 }
3060}
3061impl ast::ModuleItemOwner for SourceFile {}
3062impl ast::FnDefOwner for SourceFile {}
3063impl SourceFile {
3064 pub fn modules(&self) -> AstChildren<Module> {
3065 AstChildren::new(&self.syntax)
3066 }
3067}
3068#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3069pub struct FnDef {
3070 pub(crate) syntax: SyntaxNode,
3071}
3072impl std::fmt::Display for FnDef {
3073 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3074 std::fmt::Display::fmt(self.syntax(), f)
3075 }
3076}
3077impl AstNode for FnDef {
3078 fn can_cast(kind: SyntaxKind) -> bool {
3079 match kind {
3080 FN_DEF => true,
3081 _ => false,
3082 }
3083 }
3084 fn cast(syntax: SyntaxNode) -> Option<Self> {
3085 if Self::can_cast(syntax.kind()) {
3086 Some(Self { syntax })
3087 } else {
3088 None
3089 }
3090 }
3091 fn syntax(&self) -> &SyntaxNode {
3092 &self.syntax
3093 }
3094}
3095impl ast::VisibilityOwner for FnDef {}
3096impl ast::NameOwner for FnDef {}
3097impl ast::TypeParamsOwner for FnDef {}
3098impl ast::DocCommentsOwner for FnDef {}
3099impl ast::AttrsOwner for FnDef {}
3100impl FnDef {
3101 pub fn param_list(&self) -> Option<ParamList> {
3102 AstChildren::new(&self.syntax).next()
3103 }
3104 pub fn ret_type(&self) -> Option<RetType> {
3105 AstChildren::new(&self.syntax).next()
3106 }
3107 pub fn body(&self) -> Option<BlockExpr> {
3108 AstChildren::new(&self.syntax).next()
3109 }
3110}
3111#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3112pub struct RetType {
3113 pub(crate) syntax: SyntaxNode,
3114}
3115impl std::fmt::Display for RetType {
3116 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3117 std::fmt::Display::fmt(self.syntax(), f)
3118 }
3119}
3120impl AstNode for RetType {
3121 fn can_cast(kind: SyntaxKind) -> bool {
3122 match kind {
3123 RET_TYPE => true,
3124 _ => false,
3125 }
3126 }
3127 fn cast(syntax: SyntaxNode) -> Option<Self> {
3128 if Self::can_cast(syntax.kind()) {
3129 Some(Self { syntax })
3130 } else {
3131 None
3132 }
3133 }
3134 fn syntax(&self) -> &SyntaxNode {
3135 &self.syntax
3136 }
3137}
3138impl RetType {
3139 pub fn type_ref(&self) -> Option<TypeRef> {
3140 AstChildren::new(&self.syntax).next()
3141 }
3142}
3143#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3144pub struct StructDef {
3145 pub(crate) syntax: SyntaxNode,
3146}
3147impl std::fmt::Display for StructDef {
3148 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3149 std::fmt::Display::fmt(self.syntax(), f)
3150 }
3151}
3152impl AstNode for StructDef {
3153 fn can_cast(kind: SyntaxKind) -> bool {
3154 match kind {
3155 STRUCT_DEF => true,
3156 _ => false,
3157 }
3158 }
3159 fn cast(syntax: SyntaxNode) -> Option<Self> {
3160 if Self::can_cast(syntax.kind()) {
3161 Some(Self { syntax })
3162 } else {
3163 None
3164 }
3165 }
3166 fn syntax(&self) -> &SyntaxNode {
3167 &self.syntax
3168 }
3169}
3170impl ast::VisibilityOwner for StructDef {}
3171impl ast::NameOwner for StructDef {}
3172impl ast::TypeParamsOwner for StructDef {}
3173impl ast::AttrsOwner for StructDef {}
3174impl ast::DocCommentsOwner for StructDef {}
3175impl StructDef {}
3176#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3177pub struct UnionDef {
3178 pub(crate) syntax: SyntaxNode,
3179}
3180impl std::fmt::Display for UnionDef {
3181 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3182 std::fmt::Display::fmt(self.syntax(), f)
3183 }
3184}
3185impl AstNode for UnionDef {
3186 fn can_cast(kind: SyntaxKind) -> bool {
3187 match kind {
3188 UNION_DEF => true,
3189 _ => false,
3190 }
3191 }
3192 fn cast(syntax: SyntaxNode) -> Option<Self> {
3193 if Self::can_cast(syntax.kind()) {
3194 Some(Self { syntax })
3195 } else {
3196 None
3197 }
3198 }
3199 fn syntax(&self) -> &SyntaxNode {
3200 &self.syntax
3201 }
3202}
3203impl ast::VisibilityOwner for UnionDef {}
3204impl ast::NameOwner for UnionDef {}
3205impl ast::TypeParamsOwner for UnionDef {}
3206impl ast::AttrsOwner for UnionDef {}
3207impl ast::DocCommentsOwner for UnionDef {}
3208impl UnionDef {
3209 pub fn record_field_def_list(&self) -> Option<RecordFieldDefList> {
3210 AstChildren::new(&self.syntax).next()
3211 }
3212}
3213#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3214pub struct RecordFieldDefList {
3215 pub(crate) syntax: SyntaxNode,
3216}
3217impl std::fmt::Display for RecordFieldDefList {
3218 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3219 std::fmt::Display::fmt(self.syntax(), f)
3220 }
3221}
3222impl AstNode for RecordFieldDefList {
3223 fn can_cast(kind: SyntaxKind) -> bool {
3224 match kind {
3225 RECORD_FIELD_DEF_LIST => true,
3226 _ => false,
3227 }
3228 }
3229 fn cast(syntax: SyntaxNode) -> Option<Self> {
3230 if Self::can_cast(syntax.kind()) {
3231 Some(Self { syntax })
3232 } else {
3233 None
3234 }
3235 }
3236 fn syntax(&self) -> &SyntaxNode {
3237 &self.syntax
3238 }
3239}
3240impl RecordFieldDefList {
3241 pub fn fields(&self) -> AstChildren<RecordFieldDef> {
3242 AstChildren::new(&self.syntax)
3243 }
3244}
3245#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3246pub struct RecordFieldDef {
3247 pub(crate) syntax: SyntaxNode,
3248}
3249impl std::fmt::Display for RecordFieldDef {
3250 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3251 std::fmt::Display::fmt(self.syntax(), f)
3252 }
3253}
3254impl AstNode for RecordFieldDef {
3255 fn can_cast(kind: SyntaxKind) -> bool {
3256 match kind {
3257 RECORD_FIELD_DEF => true,
3258 _ => false,
3259 }
3260 }
3261 fn cast(syntax: SyntaxNode) -> Option<Self> {
3262 if Self::can_cast(syntax.kind()) {
3263 Some(Self { syntax })
3264 } else {
3265 None
3266 }
3267 }
3268 fn syntax(&self) -> &SyntaxNode {
3269 &self.syntax
3270 }
3271}
3272impl ast::VisibilityOwner for RecordFieldDef {}
3273impl ast::NameOwner for RecordFieldDef {}
3274impl ast::AttrsOwner for RecordFieldDef {}
3275impl ast::DocCommentsOwner for RecordFieldDef {}
3276impl ast::TypeAscriptionOwner for RecordFieldDef {}
3277impl RecordFieldDef {}
3278#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3279pub struct TupleFieldDefList {
3280 pub(crate) syntax: SyntaxNode,
3281}
3282impl std::fmt::Display for TupleFieldDefList {
3283 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3284 std::fmt::Display::fmt(self.syntax(), f)
3285 }
3286}
3287impl AstNode for TupleFieldDefList {
3288 fn can_cast(kind: SyntaxKind) -> bool {
3289 match kind {
3290 TUPLE_FIELD_DEF_LIST => true,
3291 _ => false,
3292 }
3293 }
3294 fn cast(syntax: SyntaxNode) -> Option<Self> {
3295 if Self::can_cast(syntax.kind()) {
3296 Some(Self { syntax })
3297 } else {
3298 None
3299 }
3300 }
3301 fn syntax(&self) -> &SyntaxNode {
3302 &self.syntax
3303 }
3304}
3305impl TupleFieldDefList {
3306 pub fn fields(&self) -> AstChildren<TupleFieldDef> {
3307 AstChildren::new(&self.syntax)
3308 }
3309}
3310#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3311pub struct TupleFieldDef {
3312 pub(crate) syntax: SyntaxNode,
3313}
3314impl std::fmt::Display for TupleFieldDef {
3315 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3316 std::fmt::Display::fmt(self.syntax(), f)
3317 }
3318}
3319impl AstNode for TupleFieldDef {
3320 fn can_cast(kind: SyntaxKind) -> bool {
3321 match kind {
3322 TUPLE_FIELD_DEF => true,
3323 _ => false,
3324 }
3325 }
3326 fn cast(syntax: SyntaxNode) -> Option<Self> {
3327 if Self::can_cast(syntax.kind()) {
3328 Some(Self { syntax })
3329 } else {
3330 None
3331 }
3332 }
3333 fn syntax(&self) -> &SyntaxNode {
3334 &self.syntax
3335 }
3336}
3337impl ast::VisibilityOwner for TupleFieldDef {}
3338impl ast::AttrsOwner for TupleFieldDef {}
3339impl TupleFieldDef {
3340 pub fn type_ref(&self) -> Option<TypeRef> {
3341 AstChildren::new(&self.syntax).next()
3342 }
3343}
3344#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3345pub struct EnumDef {
3346 pub(crate) syntax: SyntaxNode,
3347}
3348impl std::fmt::Display for EnumDef {
3349 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3350 std::fmt::Display::fmt(self.syntax(), f)
3351 }
3352}
3353impl AstNode for EnumDef {
3354 fn can_cast(kind: SyntaxKind) -> bool {
3355 match kind {
3356 ENUM_DEF => true,
3357 _ => false,
3358 }
3359 }
3360 fn cast(syntax: SyntaxNode) -> Option<Self> {
3361 if Self::can_cast(syntax.kind()) {
3362 Some(Self { syntax })
3363 } else {
3364 None
3365 }
3366 }
3367 fn syntax(&self) -> &SyntaxNode {
3368 &self.syntax
3369 }
3370}
3371impl ast::VisibilityOwner for EnumDef {}
3372impl ast::NameOwner for EnumDef {}
3373impl ast::TypeParamsOwner for EnumDef {}
3374impl ast::AttrsOwner for EnumDef {}
3375impl ast::DocCommentsOwner for EnumDef {}
3376impl EnumDef {
3377 pub fn variant_list(&self) -> Option<EnumVariantList> {
3378 AstChildren::new(&self.syntax).next()
3379 }
3380}
3381#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3382pub struct EnumVariantList {
3383 pub(crate) syntax: SyntaxNode,
3384}
3385impl std::fmt::Display for EnumVariantList {
3386 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3387 std::fmt::Display::fmt(self.syntax(), f)
3388 }
3389}
3390impl AstNode for EnumVariantList {
3391 fn can_cast(kind: SyntaxKind) -> bool {
3392 match kind {
3393 ENUM_VARIANT_LIST => true,
3394 _ => false,
3395 }
3396 }
3397 fn cast(syntax: SyntaxNode) -> Option<Self> {
3398 if Self::can_cast(syntax.kind()) {
3399 Some(Self { syntax })
3400 } else {
3401 None
3402 }
3403 }
3404 fn syntax(&self) -> &SyntaxNode {
3405 &self.syntax
3406 }
3407}
3408impl EnumVariantList {
3409 pub fn variants(&self) -> AstChildren<EnumVariant> {
3410 AstChildren::new(&self.syntax)
3411 }
3412}
3413#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3414pub struct EnumVariant {
3415 pub(crate) syntax: SyntaxNode,
3416}
3417impl std::fmt::Display for EnumVariant {
3418 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3419 std::fmt::Display::fmt(self.syntax(), f)
3420 }
3421}
3422impl AstNode for EnumVariant {
3423 fn can_cast(kind: SyntaxKind) -> bool {
3424 match kind {
3425 ENUM_VARIANT => true,
3426 _ => false,
3427 }
3428 }
3429 fn cast(syntax: SyntaxNode) -> Option<Self> {
3430 if Self::can_cast(syntax.kind()) {
3431 Some(Self { syntax })
3432 } else {
3433 None
3434 }
3435 }
3436 fn syntax(&self) -> &SyntaxNode {
3437 &self.syntax
3438 }
3439}
3440impl ast::NameOwner for EnumVariant {}
3441impl ast::DocCommentsOwner for EnumVariant {}
3442impl ast::AttrsOwner for EnumVariant {}
3443impl EnumVariant {
3444 pub fn expr(&self) -> Option<Expr> {
3445 AstChildren::new(&self.syntax).next()
3446 }
3447}
3448#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3449pub struct TraitDef {
3450 pub(crate) syntax: SyntaxNode,
3451}
3452impl std::fmt::Display for TraitDef {
3453 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3454 std::fmt::Display::fmt(self.syntax(), f)
3455 }
3456}
3457impl AstNode for TraitDef {
3458 fn can_cast(kind: SyntaxKind) -> bool {
3459 match kind {
3460 TRAIT_DEF => true,
3461 _ => false,
3462 }
3463 }
3464 fn cast(syntax: SyntaxNode) -> Option<Self> {
3465 if Self::can_cast(syntax.kind()) {
3466 Some(Self { syntax })
3467 } else {
3468 None
3469 }
3470 }
3471 fn syntax(&self) -> &SyntaxNode {
3472 &self.syntax
3473 }
3474}
3475impl ast::VisibilityOwner for TraitDef {}
3476impl ast::NameOwner for TraitDef {}
3477impl ast::AttrsOwner for TraitDef {}
3478impl ast::DocCommentsOwner for TraitDef {}
3479impl ast::TypeParamsOwner for TraitDef {}
3480impl ast::TypeBoundsOwner for TraitDef {}
3481impl TraitDef {
3482 pub fn item_list(&self) -> Option<ItemList> {
3483 AstChildren::new(&self.syntax).next()
3484 }
3485}
3486#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3487pub struct Module {
3488 pub(crate) syntax: SyntaxNode,
3489}
3490impl std::fmt::Display for Module {
3491 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3492 std::fmt::Display::fmt(self.syntax(), f)
3493 }
3494}
3495impl AstNode for Module {
3496 fn can_cast(kind: SyntaxKind) -> bool {
3497 match kind {
3498 MODULE => true,
3499 _ => false,
3500 }
3501 }
3502 fn cast(syntax: SyntaxNode) -> Option<Self> {
3503 if Self::can_cast(syntax.kind()) {
3504 Some(Self { syntax })
3505 } else {
3506 None
3507 }
3508 }
3509 fn syntax(&self) -> &SyntaxNode {
3510 &self.syntax
3511 }
3512}
3513impl ast::VisibilityOwner for Module {}
3514impl ast::NameOwner for Module {}
3515impl ast::AttrsOwner for Module {}
3516impl ast::DocCommentsOwner for Module {}
3517impl Module {
3518 pub fn item_list(&self) -> Option<ItemList> {
3519 AstChildren::new(&self.syntax).next()
3520 }
3521}
3522#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3523pub struct ItemList {
3524 pub(crate) syntax: SyntaxNode,
3525}
3526impl std::fmt::Display for ItemList {
3527 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3528 std::fmt::Display::fmt(self.syntax(), f)
3529 }
3530}
3531impl AstNode for ItemList {
3532 fn can_cast(kind: SyntaxKind) -> bool {
3533 match kind {
3534 ITEM_LIST => true,
3535 _ => false,
3536 }
3537 }
3538 fn cast(syntax: SyntaxNode) -> Option<Self> {
3539 if Self::can_cast(syntax.kind()) {
3540 Some(Self { syntax })
3541 } else {
3542 None
3543 }
3544 }
3545 fn syntax(&self) -> &SyntaxNode {
3546 &self.syntax
3547 }
3548}
3549impl ast::FnDefOwner for ItemList {}
3550impl ast::ModuleItemOwner for ItemList {}
3551impl ItemList {
3552 pub fn impl_items(&self) -> AstChildren<ImplItem> {
3553 AstChildren::new(&self.syntax)
3554 }
3555}
3556#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3557pub struct ConstDef {
3558 pub(crate) syntax: SyntaxNode,
3559}
3560impl std::fmt::Display for ConstDef {
3561 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3562 std::fmt::Display::fmt(self.syntax(), f)
3563 }
3564}
3565impl AstNode for ConstDef {
3566 fn can_cast(kind: SyntaxKind) -> bool {
3567 match kind {
3568 CONST_DEF => true,
3569 _ => false,
3570 }
3571 }
3572 fn cast(syntax: SyntaxNode) -> Option<Self> {
3573 if Self::can_cast(syntax.kind()) {
3574 Some(Self { syntax })
3575 } else {
3576 None
3577 }
3578 }
3579 fn syntax(&self) -> &SyntaxNode {
3580 &self.syntax
3581 }
3582}
3583impl ast::VisibilityOwner for ConstDef {}
3584impl ast::NameOwner for ConstDef {}
3585impl ast::TypeParamsOwner for ConstDef {}
3586impl ast::AttrsOwner for ConstDef {}
3587impl ast::DocCommentsOwner for ConstDef {}
3588impl ast::TypeAscriptionOwner for ConstDef {}
3589impl ConstDef {
3590 pub fn body(&self) -> Option<Expr> {
3591 AstChildren::new(&self.syntax).next()
3592 }
3593}
3594#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3595pub struct StaticDef {
3596 pub(crate) syntax: SyntaxNode,
3597}
3598impl std::fmt::Display for StaticDef {
3599 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3600 std::fmt::Display::fmt(self.syntax(), f)
3601 }
3602}
3603impl AstNode for StaticDef {
3604 fn can_cast(kind: SyntaxKind) -> bool {
3605 match kind {
3606 STATIC_DEF => true,
3607 _ => false,
3608 }
3609 }
3610 fn cast(syntax: SyntaxNode) -> Option<Self> {
3611 if Self::can_cast(syntax.kind()) {
3612 Some(Self { syntax })
3613 } else {
3614 None
3615 }
3616 }
3617 fn syntax(&self) -> &SyntaxNode {
3618 &self.syntax
3619 }
3620}
3621impl ast::VisibilityOwner for StaticDef {}
3622impl ast::NameOwner for StaticDef {}
3623impl ast::TypeParamsOwner for StaticDef {}
3624impl ast::AttrsOwner for StaticDef {}
3625impl ast::DocCommentsOwner for StaticDef {}
3626impl ast::TypeAscriptionOwner for StaticDef {}
3627impl StaticDef {
3628 pub fn body(&self) -> Option<Expr> {
3629 AstChildren::new(&self.syntax).next()
3630 }
3631}
3632#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3633pub struct TypeAliasDef {
3634 pub(crate) syntax: SyntaxNode,
3635}
3636impl std::fmt::Display for TypeAliasDef {
3637 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3638 std::fmt::Display::fmt(self.syntax(), f)
3639 }
3640}
3641impl AstNode for TypeAliasDef {
3642 fn can_cast(kind: SyntaxKind) -> bool {
3643 match kind {
3644 TYPE_ALIAS_DEF => true,
3645 _ => false,
3646 }
3647 }
3648 fn cast(syntax: SyntaxNode) -> Option<Self> {
3649 if Self::can_cast(syntax.kind()) {
3650 Some(Self { syntax })
3651 } else {
3652 None
3653 }
3654 }
3655 fn syntax(&self) -> &SyntaxNode {
3656 &self.syntax
3657 }
3658}
3659impl ast::VisibilityOwner for TypeAliasDef {}
3660impl ast::NameOwner for TypeAliasDef {}
3661impl ast::TypeParamsOwner for TypeAliasDef {}
3662impl ast::AttrsOwner for TypeAliasDef {}
3663impl ast::DocCommentsOwner for TypeAliasDef {}
3664impl ast::TypeBoundsOwner for TypeAliasDef {}
3665impl TypeAliasDef {
3666 pub fn type_ref(&self) -> Option<TypeRef> {
3667 AstChildren::new(&self.syntax).next()
3668 }
3669}
3670#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3671pub struct ImplDef {
3672 pub(crate) syntax: SyntaxNode,
3673}
3674impl std::fmt::Display for ImplDef {
3675 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3676 std::fmt::Display::fmt(self.syntax(), f)
3677 }
3678}
3679impl AstNode for ImplDef {
3680 fn can_cast(kind: SyntaxKind) -> bool {
3681 match kind {
3682 IMPL_DEF => true,
3683 _ => false,
3684 }
3685 }
3686 fn cast(syntax: SyntaxNode) -> Option<Self> {
3687 if Self::can_cast(syntax.kind()) {
3688 Some(Self { syntax })
3689 } else {
3690 None
3691 }
3692 }
3693 fn syntax(&self) -> &SyntaxNode {
3694 &self.syntax
3695 }
3696}
3697impl ast::TypeParamsOwner for ImplDef {}
3698impl ast::AttrsOwner for ImplDef {}
3699impl ImplDef {
3700 pub fn item_list(&self) -> Option<ItemList> {
3701 AstChildren::new(&self.syntax).next()
3702 }
3703}
3704#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3705pub struct ParenType {
3706 pub(crate) syntax: SyntaxNode,
3707}
3708impl std::fmt::Display for ParenType {
3709 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3710 std::fmt::Display::fmt(self.syntax(), f)
3711 }
3712}
3713impl AstNode for ParenType {
3714 fn can_cast(kind: SyntaxKind) -> bool {
3715 match kind {
3716 PAREN_TYPE => true,
3717 _ => false,
3718 }
3719 }
3720 fn cast(syntax: SyntaxNode) -> Option<Self> {
3721 if Self::can_cast(syntax.kind()) {
3722 Some(Self { syntax })
3723 } else {
3724 None
3725 }
3726 }
3727 fn syntax(&self) -> &SyntaxNode {
3728 &self.syntax
3729 }
3730}
3731impl ParenType {
3732 pub fn type_ref(&self) -> Option<TypeRef> {
3733 AstChildren::new(&self.syntax).next()
3734 }
3735}
3736#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3737pub struct TupleType {
3738 pub(crate) syntax: SyntaxNode,
3739}
3740impl std::fmt::Display for TupleType {
3741 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3742 std::fmt::Display::fmt(self.syntax(), f)
3743 }
3744}
3745impl AstNode for TupleType {
3746 fn can_cast(kind: SyntaxKind) -> bool {
3747 match kind {
3748 TUPLE_TYPE => true,
3749 _ => false,
3750 }
3751 }
3752 fn cast(syntax: SyntaxNode) -> Option<Self> {
3753 if Self::can_cast(syntax.kind()) {
3754 Some(Self { syntax })
3755 } else {
3756 None
3757 }
3758 }
3759 fn syntax(&self) -> &SyntaxNode {
3760 &self.syntax
3761 }
3762}
3763impl TupleType {
3764 pub fn fields(&self) -> AstChildren<TypeRef> {
3765 AstChildren::new(&self.syntax)
3766 }
3767}
3768#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3769pub struct NeverType {
3770 pub(crate) syntax: SyntaxNode,
3771}
3772impl std::fmt::Display for NeverType {
3773 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3774 std::fmt::Display::fmt(self.syntax(), f)
3775 }
3776}
3777impl AstNode for NeverType {
3778 fn can_cast(kind: SyntaxKind) -> bool {
3779 match kind {
3780 NEVER_TYPE => true,
3781 _ => false,
3782 }
3783 }
3784 fn cast(syntax: SyntaxNode) -> Option<Self> {
3785 if Self::can_cast(syntax.kind()) {
3786 Some(Self { syntax })
3787 } else {
3788 None
3789 }
3790 }
3791 fn syntax(&self) -> &SyntaxNode {
3792 &self.syntax
3793 }
3794}
3795impl NeverType {}
3796#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3797pub struct PathType {
3798 pub(crate) syntax: SyntaxNode,
3799}
3800impl std::fmt::Display for PathType {
3801 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3802 std::fmt::Display::fmt(self.syntax(), f)
3803 }
3804}
3805impl AstNode for PathType {
3806 fn can_cast(kind: SyntaxKind) -> bool {
3807 match kind {
3808 PATH_TYPE => true,
3809 _ => false,
3810 }
3811 }
3812 fn cast(syntax: SyntaxNode) -> Option<Self> {
3813 if Self::can_cast(syntax.kind()) {
3814 Some(Self { syntax })
3815 } else {
3816 None
3817 }
3818 }
3819 fn syntax(&self) -> &SyntaxNode {
3820 &self.syntax
3821 }
3822}
3823impl PathType {
3824 pub fn path(&self) -> Option<Path> {
3825 AstChildren::new(&self.syntax).next()
3826 }
3827}
3828#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3829pub struct PointerType {
3830 pub(crate) syntax: SyntaxNode,
3831}
3832impl std::fmt::Display for PointerType {
3833 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3834 std::fmt::Display::fmt(self.syntax(), f)
3835 }
3836}
3837impl AstNode for PointerType {
3838 fn can_cast(kind: SyntaxKind) -> bool {
3839 match kind {
3840 POINTER_TYPE => true,
3841 _ => false,
3842 }
3843 }
3844 fn cast(syntax: SyntaxNode) -> Option<Self> {
3845 if Self::can_cast(syntax.kind()) {
3846 Some(Self { syntax })
3847 } else {
3848 None
3849 }
3850 }
3851 fn syntax(&self) -> &SyntaxNode {
3852 &self.syntax
3853 }
3854}
3855impl PointerType {
3856 pub fn type_ref(&self) -> Option<TypeRef> {
3857 AstChildren::new(&self.syntax).next()
3858 }
3859}
3860#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3861pub struct ArrayType {
3862 pub(crate) syntax: SyntaxNode,
3863}
3864impl std::fmt::Display for ArrayType {
3865 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3866 std::fmt::Display::fmt(self.syntax(), f)
3867 }
3868}
3869impl AstNode for ArrayType {
3870 fn can_cast(kind: SyntaxKind) -> bool {
3871 match kind {
3872 ARRAY_TYPE => true,
3873 _ => false,
3874 }
3875 }
3876 fn cast(syntax: SyntaxNode) -> Option<Self> {
3877 if Self::can_cast(syntax.kind()) {
3878 Some(Self { syntax })
3879 } else {
3880 None
3881 }
3882 }
3883 fn syntax(&self) -> &SyntaxNode {
3884 &self.syntax
3885 }
3886}
3887impl ArrayType {
3888 pub fn type_ref(&self) -> Option<TypeRef> {
3889 AstChildren::new(&self.syntax).next()
3890 }
3891 pub fn expr(&self) -> Option<Expr> {
3892 AstChildren::new(&self.syntax).next()
3893 }
3894}
3895#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3896pub struct SliceType {
3897 pub(crate) syntax: SyntaxNode,
3898}
3899impl std::fmt::Display for SliceType {
3900 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3901 std::fmt::Display::fmt(self.syntax(), f)
3902 }
3903}
3904impl AstNode for SliceType {
3905 fn can_cast(kind: SyntaxKind) -> bool {
3906 match kind {
3907 SLICE_TYPE => true,
3908 _ => false,
3909 }
3910 }
3911 fn cast(syntax: SyntaxNode) -> Option<Self> {
3912 if Self::can_cast(syntax.kind()) {
3913 Some(Self { syntax })
3914 } else {
3915 None
3916 }
3917 }
3918 fn syntax(&self) -> &SyntaxNode {
3919 &self.syntax
3920 }
3921}
3922impl SliceType {
3923 pub fn type_ref(&self) -> Option<TypeRef> {
3924 AstChildren::new(&self.syntax).next()
3925 }
3926}
3927#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3928pub struct ReferenceType {
3929 pub(crate) syntax: SyntaxNode,
3930}
3931impl std::fmt::Display for ReferenceType {
3932 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3933 std::fmt::Display::fmt(self.syntax(), f)
3934 }
3935}
3936impl AstNode for ReferenceType {
3937 fn can_cast(kind: SyntaxKind) -> bool {
3938 match kind {
3939 REFERENCE_TYPE => true,
3940 _ => false,
3941 }
3942 }
3943 fn cast(syntax: SyntaxNode) -> Option<Self> {
3944 if Self::can_cast(syntax.kind()) {
3945 Some(Self { syntax })
3946 } else {
3947 None
3948 }
3949 }
3950 fn syntax(&self) -> &SyntaxNode {
3951 &self.syntax
3952 }
3953}
3954impl ReferenceType {
3955 pub fn type_ref(&self) -> Option<TypeRef> {
3956 AstChildren::new(&self.syntax).next()
3957 }
3958}
3959#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3960pub struct PlaceholderType {
3961 pub(crate) syntax: SyntaxNode,
3962}
3963impl std::fmt::Display for PlaceholderType {
3964 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3965 std::fmt::Display::fmt(self.syntax(), f)
3966 }
3967}
3968impl AstNode for PlaceholderType {
3969 fn can_cast(kind: SyntaxKind) -> bool {
3970 match kind {
3971 PLACEHOLDER_TYPE => true,
3972 _ => false,
3973 }
3974 }
3975 fn cast(syntax: SyntaxNode) -> Option<Self> {
3976 if Self::can_cast(syntax.kind()) {
3977 Some(Self { syntax })
3978 } else {
3979 None
3980 }
3981 }
3982 fn syntax(&self) -> &SyntaxNode {
3983 &self.syntax
3984 }
3985}
3986impl PlaceholderType {}
3987#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3988pub struct FnPointerType {
3989 pub(crate) syntax: SyntaxNode,
3990}
3991impl std::fmt::Display for FnPointerType {
3992 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3993 std::fmt::Display::fmt(self.syntax(), f)
3994 }
3995}
3996impl AstNode for FnPointerType {
3997 fn can_cast(kind: SyntaxKind) -> bool {
3998 match kind {
3999 FN_POINTER_TYPE => true,
4000 _ => false,
4001 }
4002 }
4003 fn cast(syntax: SyntaxNode) -> Option<Self> {
4004 if Self::can_cast(syntax.kind()) {
4005 Some(Self { syntax })
4006 } else {
4007 None
4008 }
4009 }
4010 fn syntax(&self) -> &SyntaxNode {
4011 &self.syntax
4012 }
4013}
4014impl FnPointerType {
4015 pub fn param_list(&self) -> Option<ParamList> {
4016 AstChildren::new(&self.syntax).next()
4017 }
4018 pub fn ret_type(&self) -> Option<RetType> {
4019 AstChildren::new(&self.syntax).next()
4020 }
4021}
4022#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4023pub struct ForType {
4024 pub(crate) syntax: SyntaxNode,
4025}
4026impl std::fmt::Display for ForType {
4027 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4028 std::fmt::Display::fmt(self.syntax(), f)
4029 }
4030}
4031impl AstNode for ForType {
4032 fn can_cast(kind: SyntaxKind) -> bool {
4033 match kind {
4034 FOR_TYPE => true,
4035 _ => false,
4036 }
4037 }
4038 fn cast(syntax: SyntaxNode) -> Option<Self> {
4039 if Self::can_cast(syntax.kind()) {
4040 Some(Self { syntax })
4041 } else {
4042 None
4043 }
4044 }
4045 fn syntax(&self) -> &SyntaxNode {
4046 &self.syntax
4047 }
4048}
4049impl ForType {
4050 pub fn type_ref(&self) -> Option<TypeRef> {
4051 AstChildren::new(&self.syntax).next()
4052 }
4053}
4054#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4055pub struct ImplTraitType {
4056 pub(crate) syntax: SyntaxNode,
4057}
4058impl std::fmt::Display for ImplTraitType {
4059 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4060 std::fmt::Display::fmt(self.syntax(), f)
4061 }
4062}
4063impl AstNode for ImplTraitType {
4064 fn can_cast(kind: SyntaxKind) -> bool {
4065 match kind {
4066 IMPL_TRAIT_TYPE => true,
4067 _ => false,
4068 }
4069 }
4070 fn cast(syntax: SyntaxNode) -> Option<Self> {
4071 if Self::can_cast(syntax.kind()) {
4072 Some(Self { syntax })
4073 } else {
4074 None
4075 }
4076 }
4077 fn syntax(&self) -> &SyntaxNode {
4078 &self.syntax
4079 }
4080}
4081impl ast::TypeBoundsOwner for ImplTraitType {}
4082impl ImplTraitType {}
4083#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4084pub struct DynTraitType {
4085 pub(crate) syntax: SyntaxNode,
4086}
4087impl std::fmt::Display for DynTraitType {
4088 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4089 std::fmt::Display::fmt(self.syntax(), f)
4090 }
4091}
4092impl AstNode for DynTraitType {
4093 fn can_cast(kind: SyntaxKind) -> bool {
4094 match kind {
4095 DYN_TRAIT_TYPE => true,
4096 _ => false,
4097 }
4098 }
4099 fn cast(syntax: SyntaxNode) -> Option<Self> {
4100 if Self::can_cast(syntax.kind()) {
4101 Some(Self { syntax })
4102 } else {
4103 None
4104 }
4105 }
4106 fn syntax(&self) -> &SyntaxNode {
4107 &self.syntax
4108 }
4109}
4110impl ast::TypeBoundsOwner for DynTraitType {}
4111impl DynTraitType {}
4112#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4113pub struct TupleExpr {
4114 pub(crate) syntax: SyntaxNode,
4115}
4116impl std::fmt::Display for TupleExpr {
4117 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4118 std::fmt::Display::fmt(self.syntax(), f)
4119 }
4120}
4121impl AstNode for TupleExpr {
4122 fn can_cast(kind: SyntaxKind) -> bool {
4123 match kind {
4124 TUPLE_EXPR => true,
4125 _ => false,
4126 }
4127 }
4128 fn cast(syntax: SyntaxNode) -> Option<Self> {
4129 if Self::can_cast(syntax.kind()) {
4130 Some(Self { syntax })
4131 } else {
4132 None
4133 }
4134 }
4135 fn syntax(&self) -> &SyntaxNode {
4136 &self.syntax
4137 }
4138}
4139impl TupleExpr {
4140 pub fn exprs(&self) -> AstChildren<Expr> {
4141 AstChildren::new(&self.syntax)
4142 }
4143}
4144#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4145pub struct ArrayExpr {
4146 pub(crate) syntax: SyntaxNode,
4147}
4148impl std::fmt::Display for ArrayExpr {
4149 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4150 std::fmt::Display::fmt(self.syntax(), f)
4151 }
4152}
4153impl AstNode for ArrayExpr {
4154 fn can_cast(kind: SyntaxKind) -> bool {
4155 match kind {
4156 ARRAY_EXPR => true,
4157 _ => false,
4158 }
4159 }
4160 fn cast(syntax: SyntaxNode) -> Option<Self> {
4161 if Self::can_cast(syntax.kind()) {
4162 Some(Self { syntax })
4163 } else {
4164 None
4165 }
4166 }
4167 fn syntax(&self) -> &SyntaxNode {
4168 &self.syntax
4169 }
4170}
4171impl ArrayExpr {
4172 pub fn exprs(&self) -> AstChildren<Expr> {
4173 AstChildren::new(&self.syntax)
4174 }
4175}
4176#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4177pub struct ParenExpr {
4178 pub(crate) syntax: SyntaxNode,
4179}
4180impl std::fmt::Display for ParenExpr {
4181 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4182 std::fmt::Display::fmt(self.syntax(), f)
4183 }
4184}
4185impl AstNode for ParenExpr {
4186 fn can_cast(kind: SyntaxKind) -> bool {
4187 match kind {
4188 PAREN_EXPR => true,
4189 _ => false,
4190 }
4191 }
4192 fn cast(syntax: SyntaxNode) -> Option<Self> {
4193 if Self::can_cast(syntax.kind()) {
4194 Some(Self { syntax })
4195 } else {
4196 None
4197 }
4198 }
4199 fn syntax(&self) -> &SyntaxNode {
4200 &self.syntax
4201 }
4202}
4203impl ParenExpr {
4204 pub fn expr(&self) -> Option<Expr> {
4205 AstChildren::new(&self.syntax).next()
4206 }
4207}
4208#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4209pub struct PathExpr {
4210 pub(crate) syntax: SyntaxNode,
4211}
4212impl std::fmt::Display for PathExpr {
4213 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4214 std::fmt::Display::fmt(self.syntax(), f)
4215 }
4216}
4217impl AstNode for PathExpr {
4218 fn can_cast(kind: SyntaxKind) -> bool {
4219 match kind {
4220 PATH_EXPR => true,
4221 _ => false,
4222 }
4223 }
4224 fn cast(syntax: SyntaxNode) -> Option<Self> {
4225 if Self::can_cast(syntax.kind()) {
4226 Some(Self { syntax })
4227 } else {
4228 None
4229 }
4230 }
4231 fn syntax(&self) -> &SyntaxNode {
4232 &self.syntax
4233 }
4234}
4235impl PathExpr {
4236 pub fn path(&self) -> Option<Path> {
4237 AstChildren::new(&self.syntax).next()
4238 }
4239}
4240#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4241pub struct LambdaExpr {
4242 pub(crate) syntax: SyntaxNode,
4243}
4244impl std::fmt::Display for LambdaExpr {
4245 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4246 std::fmt::Display::fmt(self.syntax(), f)
4247 }
4248}
4249impl AstNode for LambdaExpr {
4250 fn can_cast(kind: SyntaxKind) -> bool {
4251 match kind {
4252 LAMBDA_EXPR => true,
4253 _ => false,
4254 }
4255 }
4256 fn cast(syntax: SyntaxNode) -> Option<Self> {
4257 if Self::can_cast(syntax.kind()) {
4258 Some(Self { syntax })
4259 } else {
4260 None
4261 }
4262 }
4263 fn syntax(&self) -> &SyntaxNode {
4264 &self.syntax
4265 }
4266}
4267impl LambdaExpr {
4268 pub fn param_list(&self) -> Option<ParamList> {
4269 AstChildren::new(&self.syntax).next()
4270 }
4271 pub fn ret_type(&self) -> Option<RetType> {
4272 AstChildren::new(&self.syntax).next()
4273 }
4274 pub fn body(&self) -> Option<Expr> {
4275 AstChildren::new(&self.syntax).next()
4276 }
4277}
4278#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4279pub struct IfExpr {
4280 pub(crate) syntax: SyntaxNode,
4281}
4282impl std::fmt::Display for IfExpr {
4283 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4284 std::fmt::Display::fmt(self.syntax(), f)
4285 }
4286}
4287impl AstNode for IfExpr {
4288 fn can_cast(kind: SyntaxKind) -> bool {
4289 match kind {
4290 IF_EXPR => true,
4291 _ => false,
4292 }
4293 }
4294 fn cast(syntax: SyntaxNode) -> Option<Self> {
4295 if Self::can_cast(syntax.kind()) {
4296 Some(Self { syntax })
4297 } else {
4298 None
4299 }
4300 }
4301 fn syntax(&self) -> &SyntaxNode {
4302 &self.syntax
4303 }
4304}
4305impl IfExpr {
4306 pub fn condition(&self) -> Option<Condition> {
4307 AstChildren::new(&self.syntax).next()
4308 }
4309}
4310#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4311pub struct LoopExpr {
4312 pub(crate) syntax: SyntaxNode,
4313}
4314impl std::fmt::Display for LoopExpr {
4315 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4316 std::fmt::Display::fmt(self.syntax(), f)
4317 }
4318}
4319impl AstNode for LoopExpr {
4320 fn can_cast(kind: SyntaxKind) -> bool {
4321 match kind {
4322 LOOP_EXPR => true,
4323 _ => false,
4324 }
4325 }
4326 fn cast(syntax: SyntaxNode) -> Option<Self> {
4327 if Self::can_cast(syntax.kind()) {
4328 Some(Self { syntax })
4329 } else {
4330 None
4331 }
4332 }
4333 fn syntax(&self) -> &SyntaxNode {
4334 &self.syntax
4335 }
4336}
4337impl ast::LoopBodyOwner for LoopExpr {}
4338impl LoopExpr {}
4339#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4340pub struct TryBlockExpr {
4341 pub(crate) syntax: SyntaxNode,
4342}
4343impl std::fmt::Display for TryBlockExpr {
4344 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4345 std::fmt::Display::fmt(self.syntax(), f)
4346 }
4347}
4348impl AstNode for TryBlockExpr {
4349 fn can_cast(kind: SyntaxKind) -> bool {
4350 match kind {
4351 TRY_BLOCK_EXPR => true,
4352 _ => false,
4353 }
4354 }
4355 fn cast(syntax: SyntaxNode) -> Option<Self> {
4356 if Self::can_cast(syntax.kind()) {
4357 Some(Self { syntax })
4358 } else {
4359 None
4360 }
4361 }
4362 fn syntax(&self) -> &SyntaxNode {
4363 &self.syntax
4364 }
4365}
4366impl TryBlockExpr {
4367 pub fn body(&self) -> Option<BlockExpr> {
4368 AstChildren::new(&self.syntax).next()
4369 }
4370}
4371#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4372pub struct ForExpr {
4373 pub(crate) syntax: SyntaxNode,
4374}
4375impl std::fmt::Display for ForExpr {
4376 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4377 std::fmt::Display::fmt(self.syntax(), f)
4378 }
4379}
4380impl AstNode for ForExpr {
4381 fn can_cast(kind: SyntaxKind) -> bool {
4382 match kind {
4383 FOR_EXPR => true,
4384 _ => false,
4385 }
4386 }
4387 fn cast(syntax: SyntaxNode) -> Option<Self> {
4388 if Self::can_cast(syntax.kind()) {
4389 Some(Self { syntax })
4390 } else {
4391 None
4392 }
4393 }
4394 fn syntax(&self) -> &SyntaxNode {
4395 &self.syntax
4396 }
4397}
4398impl ast::LoopBodyOwner for ForExpr {}
4399impl ForExpr {
4400 pub fn pat(&self) -> Option<Pat> {
4401 AstChildren::new(&self.syntax).next()
4402 }
4403 pub fn iterable(&self) -> Option<Expr> {
4404 AstChildren::new(&self.syntax).next()
4405 }
4406}
4407#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4408pub struct WhileExpr {
4409 pub(crate) syntax: SyntaxNode,
4410}
4411impl std::fmt::Display for WhileExpr {
4412 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4413 std::fmt::Display::fmt(self.syntax(), f)
4414 }
4415}
4416impl AstNode for WhileExpr {
4417 fn can_cast(kind: SyntaxKind) -> bool {
4418 match kind {
4419 WHILE_EXPR => true,
4420 _ => false,
4421 }
4422 }
4423 fn cast(syntax: SyntaxNode) -> Option<Self> {
4424 if Self::can_cast(syntax.kind()) {
4425 Some(Self { syntax })
4426 } else {
4427 None
4428 }
4429 }
4430 fn syntax(&self) -> &SyntaxNode {
4431 &self.syntax
4432 }
4433}
4434impl ast::LoopBodyOwner for WhileExpr {}
4435impl WhileExpr {
4436 pub fn condition(&self) -> Option<Condition> {
4437 AstChildren::new(&self.syntax).next()
4438 }
4439}
4440#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4441pub struct ContinueExpr {
4442 pub(crate) syntax: SyntaxNode,
4443}
4444impl std::fmt::Display for ContinueExpr {
4445 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4446 std::fmt::Display::fmt(self.syntax(), f)
4447 }
4448}
4449impl AstNode for ContinueExpr {
4450 fn can_cast(kind: SyntaxKind) -> bool {
4451 match kind {
4452 CONTINUE_EXPR => true,
4453 _ => false,
4454 }
4455 }
4456 fn cast(syntax: SyntaxNode) -> Option<Self> {
4457 if Self::can_cast(syntax.kind()) {
4458 Some(Self { syntax })
4459 } else {
4460 None
4461 }
4462 }
4463 fn syntax(&self) -> &SyntaxNode {
4464 &self.syntax
4465 }
4466}
4467impl ContinueExpr {}
4468#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4469pub struct BreakExpr {
4470 pub(crate) syntax: SyntaxNode,
4471}
4472impl std::fmt::Display for BreakExpr {
4473 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4474 std::fmt::Display::fmt(self.syntax(), f)
4475 }
4476}
4477impl AstNode for BreakExpr {
4478 fn can_cast(kind: SyntaxKind) -> bool {
4479 match kind {
4480 BREAK_EXPR => true,
4481 _ => false,
4482 }
4483 }
4484 fn cast(syntax: SyntaxNode) -> Option<Self> {
4485 if Self::can_cast(syntax.kind()) {
4486 Some(Self { syntax })
4487 } else {
4488 None
4489 }
4490 }
4491 fn syntax(&self) -> &SyntaxNode {
4492 &self.syntax
4493 }
4494}
4495impl BreakExpr {
4496 pub fn expr(&self) -> Option<Expr> {
4497 AstChildren::new(&self.syntax).next()
4498 }
4499}
4500#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4501pub struct Label {
4502 pub(crate) syntax: SyntaxNode,
4503}
4504impl std::fmt::Display for Label {
4505 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4506 std::fmt::Display::fmt(self.syntax(), f)
4507 }
4508}
4509impl AstNode for Label {
4510 fn can_cast(kind: SyntaxKind) -> bool {
4511 match kind {
4512 LABEL => true,
4513 _ => false,
4514 }
4515 }
4516 fn cast(syntax: SyntaxNode) -> Option<Self> {
4517 if Self::can_cast(syntax.kind()) {
4518 Some(Self { syntax })
4519 } else {
4520 None
4521 }
4522 }
4523 fn syntax(&self) -> &SyntaxNode {
4524 &self.syntax
4525 }
4526}
4527impl Label {}
4528#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4529pub struct BlockExpr {
4530 pub(crate) syntax: SyntaxNode,
4531}
4532impl std::fmt::Display for BlockExpr {
4533 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4534 std::fmt::Display::fmt(self.syntax(), f)
4535 }
4536}
4537impl AstNode for BlockExpr {
4538 fn can_cast(kind: SyntaxKind) -> bool {
4539 match kind {
4540 BLOCK_EXPR => true,
4541 _ => false,
4542 }
4543 }
4544 fn cast(syntax: SyntaxNode) -> Option<Self> {
4545 if Self::can_cast(syntax.kind()) {
4546 Some(Self { syntax })
4547 } else {
4548 None
4549 }
4550 }
4551 fn syntax(&self) -> &SyntaxNode {
4552 &self.syntax
4553 }
4554}
4555impl BlockExpr {
4556 pub fn block(&self) -> Option<Block> {
4557 AstChildren::new(&self.syntax).next()
4558 }
4559}
4560#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4561pub struct ReturnExpr {
4562 pub(crate) syntax: SyntaxNode,
4563}
4564impl std::fmt::Display for ReturnExpr {
4565 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4566 std::fmt::Display::fmt(self.syntax(), f)
4567 }
4568}
4569impl AstNode for ReturnExpr {
4570 fn can_cast(kind: SyntaxKind) -> bool {
4571 match kind {
4572 RETURN_EXPR => true,
4573 _ => false,
4574 }
4575 }
4576 fn cast(syntax: SyntaxNode) -> Option<Self> {
4577 if Self::can_cast(syntax.kind()) {
4578 Some(Self { syntax })
4579 } else {
4580 None
4581 }
4582 }
4583 fn syntax(&self) -> &SyntaxNode {
4584 &self.syntax
4585 }
4586}
4587impl ReturnExpr {
4588 pub fn expr(&self) -> Option<Expr> {
4589 AstChildren::new(&self.syntax).next()
4590 }
4591}
4592#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4593pub struct CallExpr {
4594 pub(crate) syntax: SyntaxNode,
4595}
4596impl std::fmt::Display for CallExpr {
4597 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4598 std::fmt::Display::fmt(self.syntax(), f)
4599 }
4600}
4601impl AstNode for CallExpr {
4602 fn can_cast(kind: SyntaxKind) -> bool {
4603 match kind {
4604 CALL_EXPR => true,
4605 _ => false,
4606 }
4607 }
4608 fn cast(syntax: SyntaxNode) -> Option<Self> {
4609 if Self::can_cast(syntax.kind()) {
4610 Some(Self { syntax })
4611 } else {
4612 None
4613 }
4614 }
4615 fn syntax(&self) -> &SyntaxNode {
4616 &self.syntax
4617 }
4618}
4619impl ast::ArgListOwner for CallExpr {}
4620impl CallExpr {
4621 pub fn expr(&self) -> Option<Expr> {
4622 AstChildren::new(&self.syntax).next()
4623 }
4624}
4625#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4626pub struct MethodCallExpr {
4627 pub(crate) syntax: SyntaxNode,
4628}
4629impl std::fmt::Display for MethodCallExpr {
4630 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4631 std::fmt::Display::fmt(self.syntax(), f)
4632 }
4633}
4634impl AstNode for MethodCallExpr {
4635 fn can_cast(kind: SyntaxKind) -> bool {
4636 match kind {
4637 METHOD_CALL_EXPR => true,
4638 _ => false,
4639 }
4640 }
4641 fn cast(syntax: SyntaxNode) -> Option<Self> {
4642 if Self::can_cast(syntax.kind()) {
4643 Some(Self { syntax })
4644 } else {
4645 None
4646 }
4647 }
4648 fn syntax(&self) -> &SyntaxNode {
4649 &self.syntax
4650 }
4651}
4652impl ast::ArgListOwner for MethodCallExpr {}
4653impl MethodCallExpr {
4654 pub fn expr(&self) -> Option<Expr> {
4655 AstChildren::new(&self.syntax).next()
4656 }
4657 pub fn name_ref(&self) -> Option<NameRef> {
4658 AstChildren::new(&self.syntax).next()
4659 }
4660 pub fn type_arg_list(&self) -> Option<TypeArgList> {
4661 AstChildren::new(&self.syntax).next()
4662 }
4663}
4664#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4665pub struct IndexExpr {
4666 pub(crate) syntax: SyntaxNode,
4667}
4668impl std::fmt::Display for IndexExpr {
4669 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4670 std::fmt::Display::fmt(self.syntax(), f)
4671 }
4672}
4673impl AstNode for IndexExpr {
4674 fn can_cast(kind: SyntaxKind) -> bool {
4675 match kind {
4676 INDEX_EXPR => true,
4677 _ => false,
4678 }
4679 }
4680 fn cast(syntax: SyntaxNode) -> Option<Self> {
4681 if Self::can_cast(syntax.kind()) {
4682 Some(Self { syntax })
4683 } else {
4684 None
4685 }
4686 }
4687 fn syntax(&self) -> &SyntaxNode {
4688 &self.syntax
4689 }
4690}
4691impl IndexExpr {}
4692#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4693pub struct FieldExpr {
4694 pub(crate) syntax: SyntaxNode,
4695}
4696impl std::fmt::Display for FieldExpr {
4697 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4698 std::fmt::Display::fmt(self.syntax(), f)
4699 }
4700}
4701impl AstNode for FieldExpr {
4702 fn can_cast(kind: SyntaxKind) -> bool {
4703 match kind {
4704 FIELD_EXPR => true,
4705 _ => false,
4706 }
4707 }
4708 fn cast(syntax: SyntaxNode) -> Option<Self> {
4709 if Self::can_cast(syntax.kind()) {
4710 Some(Self { syntax })
4711 } else {
4712 None
4713 }
4714 }
4715 fn syntax(&self) -> &SyntaxNode {
4716 &self.syntax
4717 }
4718}
4719impl FieldExpr {
4720 pub fn expr(&self) -> Option<Expr> {
4721 AstChildren::new(&self.syntax).next()
4722 }
4723 pub fn name_ref(&self) -> Option<NameRef> {
4724 AstChildren::new(&self.syntax).next()
4725 }
4726}
4727#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4728pub struct AwaitExpr {
4729 pub(crate) syntax: SyntaxNode,
4730}
4731impl std::fmt::Display for AwaitExpr {
4732 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4733 std::fmt::Display::fmt(self.syntax(), f)
4734 }
4735}
4736impl AstNode for AwaitExpr {
4737 fn can_cast(kind: SyntaxKind) -> bool {
4738 match kind {
4739 AWAIT_EXPR => true,
4740 _ => false,
4741 }
4742 }
4743 fn cast(syntax: SyntaxNode) -> Option<Self> {
4744 if Self::can_cast(syntax.kind()) {
4745 Some(Self { syntax })
4746 } else {
4747 None
4748 }
4749 }
4750 fn syntax(&self) -> &SyntaxNode {
4751 &self.syntax
4752 }
4753}
4754impl AwaitExpr {
4755 pub fn expr(&self) -> Option<Expr> {
4756 AstChildren::new(&self.syntax).next()
4757 }
4758}
4759#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4760pub struct TryExpr {
4761 pub(crate) syntax: SyntaxNode,
4762}
4763impl std::fmt::Display for TryExpr {
4764 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4765 std::fmt::Display::fmt(self.syntax(), f)
4766 }
4767}
4768impl AstNode for TryExpr {
4769 fn can_cast(kind: SyntaxKind) -> bool {
4770 match kind {
4771 TRY_EXPR => true,
4772 _ => false,
4773 }
4774 }
4775 fn cast(syntax: SyntaxNode) -> Option<Self> {
4776 if Self::can_cast(syntax.kind()) {
4777 Some(Self { syntax })
4778 } else {
4779 None
4780 }
4781 }
4782 fn syntax(&self) -> &SyntaxNode {
4783 &self.syntax
4784 }
4785}
4786impl TryExpr {
4787 pub fn expr(&self) -> Option<Expr> {
4788 AstChildren::new(&self.syntax).next()
4789 }
4790}
4791#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4792pub struct CastExpr {
4793 pub(crate) syntax: SyntaxNode,
4794}
4795impl std::fmt::Display for CastExpr {
4796 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4797 std::fmt::Display::fmt(self.syntax(), f)
4798 }
4799}
4800impl AstNode for CastExpr {
4801 fn can_cast(kind: SyntaxKind) -> bool {
4802 match kind {
4803 CAST_EXPR => true,
4804 _ => false,
4805 }
4806 }
4807 fn cast(syntax: SyntaxNode) -> Option<Self> {
4808 if Self::can_cast(syntax.kind()) {
4809 Some(Self { syntax })
4810 } else {
4811 None
4812 }
4813 }
4814 fn syntax(&self) -> &SyntaxNode {
4815 &self.syntax
4816 }
4817}
4818impl CastExpr {
4819 pub fn expr(&self) -> Option<Expr> {
4820 AstChildren::new(&self.syntax).next()
4821 }
4822 pub fn type_ref(&self) -> Option<TypeRef> {
4823 AstChildren::new(&self.syntax).next()
4824 }
4825}
4826#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4827pub struct RefExpr {
4828 pub(crate) syntax: SyntaxNode,
4829}
4830impl std::fmt::Display for RefExpr {
4831 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4832 std::fmt::Display::fmt(self.syntax(), f)
4833 }
4834}
4835impl AstNode for RefExpr {
4836 fn can_cast(kind: SyntaxKind) -> bool {
4837 match kind {
4838 REF_EXPR => true,
4839 _ => false,
4840 }
4841 }
4842 fn cast(syntax: SyntaxNode) -> Option<Self> {
4843 if Self::can_cast(syntax.kind()) {
4844 Some(Self { syntax })
4845 } else {
4846 None
4847 }
4848 }
4849 fn syntax(&self) -> &SyntaxNode {
4850 &self.syntax
4851 }
4852}
4853impl RefExpr {
4854 pub fn expr(&self) -> Option<Expr> {
4855 AstChildren::new(&self.syntax).next()
4856 }
4857}
4858#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4859pub struct PrefixExpr {
4860 pub(crate) syntax: SyntaxNode,
4861}
4862impl std::fmt::Display for PrefixExpr {
4863 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4864 std::fmt::Display::fmt(self.syntax(), f)
4865 }
4866}
4867impl AstNode for PrefixExpr {
4868 fn can_cast(kind: SyntaxKind) -> bool {
4869 match kind {
4870 PREFIX_EXPR => true,
4871 _ => false,
4872 }
4873 }
4874 fn cast(syntax: SyntaxNode) -> Option<Self> {
4875 if Self::can_cast(syntax.kind()) {
4876 Some(Self { syntax })
4877 } else {
4878 None
4879 }
4880 }
4881 fn syntax(&self) -> &SyntaxNode {
4882 &self.syntax
4883 }
4884}
4885impl PrefixExpr {
4886 pub fn expr(&self) -> Option<Expr> {
4887 AstChildren::new(&self.syntax).next()
4888 }
4889}
4890#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4891pub struct BoxExpr {
4892 pub(crate) syntax: SyntaxNode,
4893}
4894impl std::fmt::Display for BoxExpr {
4895 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4896 std::fmt::Display::fmt(self.syntax(), f)
4897 }
4898}
4899impl AstNode for BoxExpr {
4900 fn can_cast(kind: SyntaxKind) -> bool {
4901 match kind {
4902 BOX_EXPR => true,
4903 _ => false,
4904 }
4905 }
4906 fn cast(syntax: SyntaxNode) -> Option<Self> {
4907 if Self::can_cast(syntax.kind()) {
4908 Some(Self { syntax })
4909 } else {
4910 None
4911 }
4912 }
4913 fn syntax(&self) -> &SyntaxNode {
4914 &self.syntax
4915 }
4916}
4917impl BoxExpr {
4918 pub fn expr(&self) -> Option<Expr> {
4919 AstChildren::new(&self.syntax).next()
4920 }
4921}
4922#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4923pub struct RangeExpr {
4924 pub(crate) syntax: SyntaxNode,
4925}
4926impl std::fmt::Display for RangeExpr {
4927 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4928 std::fmt::Display::fmt(self.syntax(), f)
4929 }
4930}
4931impl AstNode for RangeExpr {
4932 fn can_cast(kind: SyntaxKind) -> bool {
4933 match kind {
4934 RANGE_EXPR => true,
4935 _ => false,
4936 }
4937 }
4938 fn cast(syntax: SyntaxNode) -> Option<Self> {
4939 if Self::can_cast(syntax.kind()) {
4940 Some(Self { syntax })
4941 } else {
4942 None
4943 }
4944 }
4945 fn syntax(&self) -> &SyntaxNode {
4946 &self.syntax
4947 }
4948}
4949impl RangeExpr {}
4950#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4951pub struct BinExpr {
4952 pub(crate) syntax: SyntaxNode,
4953}
4954impl std::fmt::Display for BinExpr {
4955 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4956 std::fmt::Display::fmt(self.syntax(), f)
4957 }
4958}
4959impl AstNode for BinExpr {
4960 fn can_cast(kind: SyntaxKind) -> bool {
4961 match kind {
4962 BIN_EXPR => true,
4963 _ => false,
4964 }
4965 }
4966 fn cast(syntax: SyntaxNode) -> Option<Self> {
4967 if Self::can_cast(syntax.kind()) {
4968 Some(Self { syntax })
4969 } else {
4970 None
4971 }
4972 }
4973 fn syntax(&self) -> &SyntaxNode {
4974 &self.syntax
4975 }
4976}
4977impl BinExpr {}
4978#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4979pub struct Literal {
4980 pub(crate) syntax: SyntaxNode,
4981}
4982impl std::fmt::Display for Literal {
4983 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4984 std::fmt::Display::fmt(self.syntax(), f)
4985 }
4986}
4987impl AstNode for Literal {
4988 fn can_cast(kind: SyntaxKind) -> bool {
4989 match kind {
4990 LITERAL => true,
4991 _ => false,
4992 }
4993 }
4994 fn cast(syntax: SyntaxNode) -> Option<Self> {
4995 if Self::can_cast(syntax.kind()) {
4996 Some(Self { syntax })
4997 } else {
4998 None
4999 }
5000 }
5001 fn syntax(&self) -> &SyntaxNode {
5002 &self.syntax
5003 }
5004}
5005impl Literal {}
5006#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5007pub struct MatchExpr {
5008 pub(crate) syntax: SyntaxNode,
5009}
5010impl std::fmt::Display for MatchExpr {
5011 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5012 std::fmt::Display::fmt(self.syntax(), f)
5013 }
5014}
5015impl AstNode for MatchExpr {
5016 fn can_cast(kind: SyntaxKind) -> bool {
5017 match kind {
5018 MATCH_EXPR => true,
5019 _ => false,
5020 }
5021 }
5022 fn cast(syntax: SyntaxNode) -> Option<Self> {
5023 if Self::can_cast(syntax.kind()) {
5024 Some(Self { syntax })
5025 } else {
5026 None
5027 }
5028 }
5029 fn syntax(&self) -> &SyntaxNode {
5030 &self.syntax
5031 }
5032}
5033impl MatchExpr {
5034 pub fn expr(&self) -> Option<Expr> {
5035 AstChildren::new(&self.syntax).next()
5036 }
5037 pub fn match_arm_list(&self) -> Option<MatchArmList> {
5038 AstChildren::new(&self.syntax).next()
5039 }
5040}
5041#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5042pub struct MatchArmList {
5043 pub(crate) syntax: SyntaxNode,
5044}
5045impl std::fmt::Display for MatchArmList {
5046 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5047 std::fmt::Display::fmt(self.syntax(), f)
5048 }
5049}
5050impl AstNode for MatchArmList {
5051 fn can_cast(kind: SyntaxKind) -> bool {
5052 match kind {
5053 MATCH_ARM_LIST => true,
5054 _ => false,
5055 }
5056 }
5057 fn cast(syntax: SyntaxNode) -> Option<Self> {
5058 if Self::can_cast(syntax.kind()) {
5059 Some(Self { syntax })
5060 } else {
5061 None
5062 }
5063 }
5064 fn syntax(&self) -> &SyntaxNode {
5065 &self.syntax
5066 }
5067}
5068impl ast::AttrsOwner for MatchArmList {}
5069impl MatchArmList {
5070 pub fn arms(&self) -> AstChildren<MatchArm> {
5071 AstChildren::new(&self.syntax)
5072 }
5073}
5074#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5075pub struct MatchArm {
5076 pub(crate) syntax: SyntaxNode,
5077}
5078impl std::fmt::Display for MatchArm {
5079 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5080 std::fmt::Display::fmt(self.syntax(), f)
5081 }
5082}
5083impl AstNode for MatchArm {
5084 fn can_cast(kind: SyntaxKind) -> bool {
5085 match kind {
5086 MATCH_ARM => true,
5087 _ => false,
5088 }
5089 }
5090 fn cast(syntax: SyntaxNode) -> Option<Self> {
5091 if Self::can_cast(syntax.kind()) {
5092 Some(Self { syntax })
5093 } else {
5094 None
5095 }
5096 }
5097 fn syntax(&self) -> &SyntaxNode {
5098 &self.syntax
5099 }
5100}
5101impl ast::AttrsOwner for MatchArm {}
5102impl MatchArm {
5103 pub fn pat(&self) -> Option<Pat> {
5104 AstChildren::new(&self.syntax).next()
5105 }
5106 pub fn guard(&self) -> Option<MatchGuard> {
5107 AstChildren::new(&self.syntax).next()
5108 }
5109 pub fn expr(&self) -> Option<Expr> {
5110 AstChildren::new(&self.syntax).next()
5111 }
5112}
5113#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5114pub struct MatchGuard {
5115 pub(crate) syntax: SyntaxNode,
5116}
5117impl std::fmt::Display for MatchGuard {
5118 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5119 std::fmt::Display::fmt(self.syntax(), f)
5120 }
5121}
5122impl AstNode for MatchGuard {
5123 fn can_cast(kind: SyntaxKind) -> bool {
5124 match kind {
5125 MATCH_GUARD => true,
5126 _ => false,
5127 }
5128 }
5129 fn cast(syntax: SyntaxNode) -> Option<Self> {
5130 if Self::can_cast(syntax.kind()) {
5131 Some(Self { syntax })
5132 } else {
5133 None
5134 }
5135 }
5136 fn syntax(&self) -> &SyntaxNode {
5137 &self.syntax
5138 }
5139}
5140impl MatchGuard {
5141 pub fn expr(&self) -> Option<Expr> {
5142 AstChildren::new(&self.syntax).next()
5143 }
5144}
5145#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5146pub struct RecordLit {
5147 pub(crate) syntax: SyntaxNode,
5148}
5149impl std::fmt::Display for RecordLit {
5150 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5151 std::fmt::Display::fmt(self.syntax(), f)
5152 }
5153}
5154impl AstNode for RecordLit {
5155 fn can_cast(kind: SyntaxKind) -> bool {
5156 match kind {
5157 RECORD_LIT => true,
5158 _ => false,
5159 }
5160 }
5161 fn cast(syntax: SyntaxNode) -> Option<Self> {
5162 if Self::can_cast(syntax.kind()) {
5163 Some(Self { syntax })
5164 } else {
5165 None
5166 }
5167 }
5168 fn syntax(&self) -> &SyntaxNode {
5169 &self.syntax
5170 }
5171}
5172impl RecordLit {
5173 pub fn path(&self) -> Option<Path> {
5174 AstChildren::new(&self.syntax).next()
5175 }
5176 pub fn record_field_list(&self) -> Option<RecordFieldList> {
5177 AstChildren::new(&self.syntax).next()
5178 }
5179}
5180#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5181pub struct RecordFieldList {
5182 pub(crate) syntax: SyntaxNode,
5183}
5184impl std::fmt::Display for RecordFieldList {
5185 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5186 std::fmt::Display::fmt(self.syntax(), f)
5187 }
5188}
5189impl AstNode for RecordFieldList {
5190 fn can_cast(kind: SyntaxKind) -> bool {
5191 match kind {
5192 RECORD_FIELD_LIST => true,
5193 _ => false,
5194 }
5195 }
5196 fn cast(syntax: SyntaxNode) -> Option<Self> {
5197 if Self::can_cast(syntax.kind()) {
5198 Some(Self { syntax })
5199 } else {
5200 None
5201 }
5202 }
5203 fn syntax(&self) -> &SyntaxNode {
5204 &self.syntax
5205 }
5206}
5207impl RecordFieldList {
5208 pub fn fields(&self) -> AstChildren<RecordField> {
5209 AstChildren::new(&self.syntax)
5210 }
5211 pub fn spread(&self) -> Option<Expr> {
5212 AstChildren::new(&self.syntax).next()
5213 }
5214}
5215#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5216pub struct RecordField {
5217 pub(crate) syntax: SyntaxNode,
5218}
5219impl ast::AttrsOwner for RecordField {}
5220impl std::fmt::Display for RecordField {
5221 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5222 std::fmt::Display::fmt(self.syntax(), f)
5223 }
5224}
5225impl AstNode for RecordField {
5226 fn can_cast(kind: SyntaxKind) -> bool {
5227 match kind {
5228 RECORD_FIELD => true,
5229 _ => false,
5230 }
5231 }
5232 fn cast(syntax: SyntaxNode) -> Option<Self> {
5233 if Self::can_cast(syntax.kind()) {
5234 Some(Self { syntax })
5235 } else {
5236 None
5237 }
5238 }
5239 fn syntax(&self) -> &SyntaxNode {
5240 &self.syntax
5241 }
5242}
5243impl RecordField {
5244 pub fn name_ref(&self) -> Option<NameRef> {
5245 AstChildren::new(&self.syntax).next()
5246 }
5247 pub fn expr(&self) -> Option<Expr> {
5248 AstChildren::new(&self.syntax).next()
5249 }
5250}
5251#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5252pub struct OrPat {
5253 pub(crate) syntax: SyntaxNode,
5254}
5255impl std::fmt::Display for OrPat {
5256 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5257 std::fmt::Display::fmt(self.syntax(), f)
5258 }
5259}
5260impl AstNode for OrPat {
5261 fn can_cast(kind: SyntaxKind) -> bool {
5262 match kind {
5263 OR_PAT => true,
5264 _ => false,
5265 }
5266 }
5267 fn cast(syntax: SyntaxNode) -> Option<Self> {
5268 if Self::can_cast(syntax.kind()) {
5269 Some(Self { syntax })
5270 } else {
5271 None
5272 }
5273 }
5274 fn syntax(&self) -> &SyntaxNode {
5275 &self.syntax
5276 }
5277}
5278impl OrPat {
5279 pub fn pats(&self) -> AstChildren<Pat> {
5280 AstChildren::new(&self.syntax)
5281 }
5282}
5283#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5284pub struct ParenPat {
5285 pub(crate) syntax: SyntaxNode,
5286}
5287impl std::fmt::Display for ParenPat {
5288 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5289 std::fmt::Display::fmt(self.syntax(), f)
5290 }
5291}
5292impl AstNode for ParenPat {
5293 fn can_cast(kind: SyntaxKind) -> bool {
5294 match kind {
5295 PAREN_PAT => true,
5296 _ => false,
5297 }
5298 }
5299 fn cast(syntax: SyntaxNode) -> Option<Self> {
5300 if Self::can_cast(syntax.kind()) {
5301 Some(Self { syntax })
5302 } else {
5303 None
5304 }
5305 }
5306 fn syntax(&self) -> &SyntaxNode {
5307 &self.syntax
5308 }
5309}
5310impl ParenPat {
5311 pub fn pat(&self) -> Option<Pat> {
5312 AstChildren::new(&self.syntax).next()
5313 }
5314}
5315#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5316pub struct RefPat {
5317 pub(crate) syntax: SyntaxNode,
5318}
5319impl std::fmt::Display for RefPat {
5320 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5321 std::fmt::Display::fmt(self.syntax(), f)
5322 }
5323}
5324impl AstNode for RefPat {
5325 fn can_cast(kind: SyntaxKind) -> bool {
5326 match kind {
5327 REF_PAT => true,
5328 _ => false,
5329 }
5330 }
5331 fn cast(syntax: SyntaxNode) -> Option<Self> {
5332 if Self::can_cast(syntax.kind()) {
5333 Some(Self { syntax })
5334 } else {
5335 None
5336 }
5337 }
5338 fn syntax(&self) -> &SyntaxNode {
5339 &self.syntax
5340 }
5341}
5342impl RefPat {
5343 pub fn pat(&self) -> Option<Pat> {
5344 AstChildren::new(&self.syntax).next()
5345 }
5346}
5347#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5348pub struct BoxPat {
5349 pub(crate) syntax: SyntaxNode,
5350}
5351impl std::fmt::Display for BoxPat {
5352 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5353 std::fmt::Display::fmt(self.syntax(), f)
5354 }
5355}
5356impl AstNode for BoxPat {
5357 fn can_cast(kind: SyntaxKind) -> bool {
5358 match kind {
5359 BOX_PAT => true,
5360 _ => false,
5361 }
5362 }
5363 fn cast(syntax: SyntaxNode) -> Option<Self> {
5364 if Self::can_cast(syntax.kind()) {
5365 Some(Self { syntax })
5366 } else {
5367 None
5368 }
5369 }
5370 fn syntax(&self) -> &SyntaxNode {
5371 &self.syntax
5372 }
5373}
5374impl BoxPat {
5375 pub fn pat(&self) -> Option<Pat> {
5376 AstChildren::new(&self.syntax).next()
5377 }
5378}
5379#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5380pub struct BindPat {
5381 pub(crate) syntax: SyntaxNode,
5382}
5383impl std::fmt::Display for BindPat {
5384 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5385 std::fmt::Display::fmt(self.syntax(), f)
5386 }
5387}
5388impl AstNode for BindPat {
5389 fn can_cast(kind: SyntaxKind) -> bool {
5390 match kind {
5391 BIND_PAT => true,
5392 _ => false,
5393 }
5394 }
5395 fn cast(syntax: SyntaxNode) -> Option<Self> {
5396 if Self::can_cast(syntax.kind()) {
5397 Some(Self { syntax })
5398 } else {
5399 None
5400 }
5401 }
5402 fn syntax(&self) -> &SyntaxNode {
5403 &self.syntax
5404 }
5405}
5406impl ast::NameOwner for BindPat {}
5407impl BindPat {
5408 pub fn pat(&self) -> Option<Pat> {
5409 AstChildren::new(&self.syntax).next()
5410 }
5411}
5412#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5413pub struct PlaceholderPat {
5414 pub(crate) syntax: SyntaxNode,
5415}
5416impl std::fmt::Display for PlaceholderPat {
5417 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5418 std::fmt::Display::fmt(self.syntax(), f)
5419 }
5420}
5421impl AstNode for PlaceholderPat {
5422 fn can_cast(kind: SyntaxKind) -> bool {
5423 match kind {
5424 PLACEHOLDER_PAT => true,
5425 _ => false,
5426 }
5427 }
5428 fn cast(syntax: SyntaxNode) -> Option<Self> {
5429 if Self::can_cast(syntax.kind()) {
5430 Some(Self { syntax })
5431 } else {
5432 None
5433 }
5434 }
5435 fn syntax(&self) -> &SyntaxNode {
5436 &self.syntax
5437 }
5438}
5439impl PlaceholderPat {}
5440#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5441pub struct DotDotPat {
5442 pub(crate) syntax: SyntaxNode,
5443}
5444impl std::fmt::Display for DotDotPat {
5445 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5446 std::fmt::Display::fmt(self.syntax(), f)
5447 }
5448}
5449impl AstNode for DotDotPat {
5450 fn can_cast(kind: SyntaxKind) -> bool {
5451 match kind {
5452 DOT_DOT_PAT => true,
5453 _ => false,
5454 }
5455 }
5456 fn cast(syntax: SyntaxNode) -> Option<Self> {
5457 if Self::can_cast(syntax.kind()) {
5458 Some(Self { syntax })
5459 } else {
5460 None
5461 }
5462 }
5463 fn syntax(&self) -> &SyntaxNode {
5464 &self.syntax
5465 }
5466}
5467impl DotDotPat {}
5468#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5469pub struct PathPat {
5470 pub(crate) syntax: SyntaxNode,
5471}
5472impl std::fmt::Display for PathPat {
5473 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5474 std::fmt::Display::fmt(self.syntax(), f)
5475 }
5476}
5477impl AstNode for PathPat {
5478 fn can_cast(kind: SyntaxKind) -> bool {
5479 match kind {
5480 PATH_PAT => true,
5481 _ => false,
5482 }
5483 }
5484 fn cast(syntax: SyntaxNode) -> Option<Self> {
5485 if Self::can_cast(syntax.kind()) {
5486 Some(Self { syntax })
5487 } else {
5488 None
5489 }
5490 }
5491 fn syntax(&self) -> &SyntaxNode {
5492 &self.syntax
5493 }
5494}
5495impl PathPat {
5496 pub fn path(&self) -> Option<Path> {
5497 AstChildren::new(&self.syntax).next()
5498 }
5499}
5500#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5501pub struct SlicePat {
5502 pub(crate) syntax: SyntaxNode,
5503}
5504impl std::fmt::Display for SlicePat {
5505 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5506 std::fmt::Display::fmt(self.syntax(), f)
5507 }
5508}
5509impl AstNode for SlicePat {
5510 fn can_cast(kind: SyntaxKind) -> bool {
5511 match kind {
5512 SLICE_PAT => true,
5513 _ => false,
5514 }
5515 }
5516 fn cast(syntax: SyntaxNode) -> Option<Self> {
5517 if Self::can_cast(syntax.kind()) {
5518 Some(Self { syntax })
5519 } else {
5520 None
5521 }
5522 }
5523 fn syntax(&self) -> &SyntaxNode {
5524 &self.syntax
5525 }
5526}
5527impl SlicePat {
5528 pub fn args(&self) -> AstChildren<Pat> {
5529 AstChildren::new(&self.syntax)
5530 }
5531}
5532#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5533pub struct RangePat {
5534 pub(crate) syntax: SyntaxNode,
5535}
5536impl std::fmt::Display for RangePat {
5537 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5538 std::fmt::Display::fmt(self.syntax(), f)
5539 }
5540}
5541impl AstNode for RangePat {
5542 fn can_cast(kind: SyntaxKind) -> bool {
5543 match kind {
5544 RANGE_PAT => true,
5545 _ => false,
5546 }
5547 }
5548 fn cast(syntax: SyntaxNode) -> Option<Self> {
5549 if Self::can_cast(syntax.kind()) {
5550 Some(Self { syntax })
5551 } else {
5552 None
5553 }
5554 }
5555 fn syntax(&self) -> &SyntaxNode {
5556 &self.syntax
5557 }
5558}
5559impl RangePat {}
5560#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5561pub struct LiteralPat {
5562 pub(crate) syntax: SyntaxNode,
5563}
5564impl std::fmt::Display for LiteralPat {
5565 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5566 std::fmt::Display::fmt(self.syntax(), f)
5567 }
5568}
5569impl AstNode for LiteralPat {
5570 fn can_cast(kind: SyntaxKind) -> bool {
5571 match kind {
5572 LITERAL_PAT => true,
5573 _ => false,
5574 }
5575 }
5576 fn cast(syntax: SyntaxNode) -> Option<Self> {
5577 if Self::can_cast(syntax.kind()) {
5578 Some(Self { syntax })
5579 } else {
5580 None
5581 }
5582 }
5583 fn syntax(&self) -> &SyntaxNode {
5584 &self.syntax
5585 }
5586}
5587impl LiteralPat {
5588 pub fn literal(&self) -> Option<Literal> {
5589 AstChildren::new(&self.syntax).next()
5590 }
5591}
5592#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5593pub struct MacroPat {
5594 pub(crate) syntax: SyntaxNode,
5595}
5596impl std::fmt::Display for MacroPat {
5597 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5598 std::fmt::Display::fmt(self.syntax(), f)
5599 }
5600}
5601impl AstNode for MacroPat {
5602 fn can_cast(kind: SyntaxKind) -> bool {
5603 match kind {
5604 MACRO_PAT => true,
5605 _ => false,
5606 }
5607 }
5608 fn cast(syntax: SyntaxNode) -> Option<Self> {
5609 if Self::can_cast(syntax.kind()) {
5610 Some(Self { syntax })
5611 } else {
5612 None
5613 }
5614 }
5615 fn syntax(&self) -> &SyntaxNode {
5616 &self.syntax
5617 }
5618}
5619impl MacroPat {
5620 pub fn macro_call(&self) -> Option<MacroCall> {
5621 AstChildren::new(&self.syntax).next()
5622 }
5623}
5624#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5625pub struct RecordPat {
5626 pub(crate) syntax: SyntaxNode,
5627}
5628impl std::fmt::Display for RecordPat {
5629 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5630 std::fmt::Display::fmt(self.syntax(), f)
5631 }
5632}
5633impl AstNode for RecordPat {
5634 fn can_cast(kind: SyntaxKind) -> bool {
5635 match kind {
5636 RECORD_PAT => true,
5637 _ => false,
5638 }
5639 }
5640 fn cast(syntax: SyntaxNode) -> Option<Self> {
5641 if Self::can_cast(syntax.kind()) {
5642 Some(Self { syntax })
5643 } else {
5644 None
5645 }
5646 }
5647 fn syntax(&self) -> &SyntaxNode {
5648 &self.syntax
5649 }
5650}
5651impl RecordPat {
5652 pub fn record_field_pat_list(&self) -> Option<RecordFieldPatList> {
5653 AstChildren::new(&self.syntax).next()
5654 }
5655 pub fn path(&self) -> Option<Path> {
5656 AstChildren::new(&self.syntax).next()
5657 }
5658}
5659#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5660pub struct RecordFieldPatList {
5661 pub(crate) syntax: SyntaxNode,
5662}
5663impl std::fmt::Display for RecordFieldPatList {
5664 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5665 std::fmt::Display::fmt(self.syntax(), f)
5666 }
5667}
5668impl AstNode for RecordFieldPatList {
5669 fn can_cast(kind: SyntaxKind) -> bool {
5670 match kind {
5671 RECORD_FIELD_PAT_LIST => true,
5672 _ => false,
5673 }
5674 }
5675 fn cast(syntax: SyntaxNode) -> Option<Self> {
5676 if Self::can_cast(syntax.kind()) {
5677 Some(Self { syntax })
5678 } else {
5679 None
5680 }
5681 }
5682 fn syntax(&self) -> &SyntaxNode {
5683 &self.syntax
5684 }
5685}
5686impl RecordFieldPatList {
5687 pub fn record_field_pats(&self) -> AstChildren<RecordFieldPat> {
5688 AstChildren::new(&self.syntax)
5689 }
5690 pub fn bind_pats(&self) -> AstChildren<BindPat> {
5691 AstChildren::new(&self.syntax)
5692 }
5693}
5694#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5695pub struct RecordFieldPat {
5696 pub(crate) syntax: SyntaxNode,
5697}
5698impl std::fmt::Display for RecordFieldPat {
5699 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5700 std::fmt::Display::fmt(self.syntax(), f)
5701 }
5702}
5703impl AstNode for RecordFieldPat {
5704 fn can_cast(kind: SyntaxKind) -> bool {
5705 match kind {
5706 RECORD_FIELD_PAT => true,
5707 _ => false,
5708 }
5709 }
5710 fn cast(syntax: SyntaxNode) -> Option<Self> {
5711 if Self::can_cast(syntax.kind()) {
5712 Some(Self { syntax })
5713 } else {
5714 None
5715 }
5716 }
5717 fn syntax(&self) -> &SyntaxNode {
5718 &self.syntax
5719 }
5720}
5721impl ast::NameOwner for RecordFieldPat {}
5722impl RecordFieldPat {
5723 pub fn pat(&self) -> Option<Pat> {
5724 AstChildren::new(&self.syntax).next()
5725 }
5726}
5727#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5728pub struct TupleStructPat {
5729 pub(crate) syntax: SyntaxNode,
5730}
5731impl std::fmt::Display for TupleStructPat {
5732 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5733 std::fmt::Display::fmt(self.syntax(), f)
5734 }
5735}
5736impl AstNode for TupleStructPat {
5737 fn can_cast(kind: SyntaxKind) -> bool {
5738 match kind {
5739 TUPLE_STRUCT_PAT => true,
5740 _ => false,
5741 }
5742 }
5743 fn cast(syntax: SyntaxNode) -> Option<Self> {
5744 if Self::can_cast(syntax.kind()) {
5745 Some(Self { syntax })
5746 } else {
5747 None
5748 }
5749 }
5750 fn syntax(&self) -> &SyntaxNode {
5751 &self.syntax
5752 }
5753}
5754impl TupleStructPat {
5755 pub fn path(&self) -> Option<Path> {
5756 AstChildren::new(&self.syntax).next()
5757 }
5758 pub fn args(&self) -> AstChildren<Pat> {
5759 AstChildren::new(&self.syntax)
5760 }
5761}
5762#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5763pub struct TuplePat {
5764 pub(crate) syntax: SyntaxNode,
5765}
5766impl std::fmt::Display for TuplePat {
5767 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5768 std::fmt::Display::fmt(self.syntax(), f)
5769 }
5770}
5771impl AstNode for TuplePat {
5772 fn can_cast(kind: SyntaxKind) -> bool {
5773 match kind {
5774 TUPLE_PAT => true,
5775 _ => false,
5776 }
5777 }
5778 fn cast(syntax: SyntaxNode) -> Option<Self> {
5779 if Self::can_cast(syntax.kind()) {
5780 Some(Self { syntax })
5781 } else {
5782 None
5783 }
5784 }
5785 fn syntax(&self) -> &SyntaxNode {
5786 &self.syntax
5787 }
5788}
5789impl TuplePat {
5790 pub fn args(&self) -> AstChildren<Pat> {
5791 AstChildren::new(&self.syntax)
5792 }
5793}
5794#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5795pub struct Visibility {
5796 pub(crate) syntax: SyntaxNode,
5797}
5798impl std::fmt::Display for Visibility {
5799 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5800 std::fmt::Display::fmt(self.syntax(), f)
5801 }
5802}
5803impl AstNode for Visibility {
5804 fn can_cast(kind: SyntaxKind) -> bool {
5805 match kind {
5806 VISIBILITY => true,
5807 _ => false,
5808 }
5809 }
5810 fn cast(syntax: SyntaxNode) -> Option<Self> {
5811 if Self::can_cast(syntax.kind()) {
5812 Some(Self { syntax })
5813 } else {
5814 None
5815 }
5816 }
5817 fn syntax(&self) -> &SyntaxNode {
5818 &self.syntax
5819 }
5820}
5821impl Visibility {}
5822#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5823pub struct Name {
5824 pub(crate) syntax: SyntaxNode,
5825}
5826impl std::fmt::Display for Name {
5827 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5828 std::fmt::Display::fmt(self.syntax(), f)
5829 }
5830}
5831impl AstNode for Name {
5832 fn can_cast(kind: SyntaxKind) -> bool {
5833 match kind {
5834 NAME => true,
5835 _ => false,
5836 }
5837 }
5838 fn cast(syntax: SyntaxNode) -> Option<Self> {
5839 if Self::can_cast(syntax.kind()) {
5840 Some(Self { syntax })
5841 } else {
5842 None
5843 }
5844 }
5845 fn syntax(&self) -> &SyntaxNode {
5846 &self.syntax
5847 }
5848}
5849impl Name {}
5850#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5851pub struct NameRef {
5852 pub(crate) syntax: SyntaxNode,
5853}
5854impl std::fmt::Display for NameRef {
5855 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5856 std::fmt::Display::fmt(self.syntax(), f)
5857 }
5858}
5859impl AstNode for NameRef {
5860 fn can_cast(kind: SyntaxKind) -> bool {
5861 match kind {
5862 NAME_REF => true,
5863 _ => false,
5864 }
5865 }
5866 fn cast(syntax: SyntaxNode) -> Option<Self> {
5867 if Self::can_cast(syntax.kind()) {
5868 Some(Self { syntax })
5869 } else {
5870 None
5871 }
5872 }
5873 fn syntax(&self) -> &SyntaxNode {
5874 &self.syntax
5875 }
5876}
5877impl NameRef {}
5878#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5879pub struct MacroCall {
5880 pub(crate) syntax: SyntaxNode,
5881}
5882impl std::fmt::Display for MacroCall {
5883 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5884 std::fmt::Display::fmt(self.syntax(), f)
5885 }
5886}
5887impl AstNode for MacroCall {
5888 fn can_cast(kind: SyntaxKind) -> bool {
5889 match kind {
5890 MACRO_CALL => true,
5891 _ => false,
5892 }
5893 }
5894 fn cast(syntax: SyntaxNode) -> Option<Self> {
5895 if Self::can_cast(syntax.kind()) {
5896 Some(Self { syntax })
5897 } else {
5898 None
5899 }
5900 }
5901 fn syntax(&self) -> &SyntaxNode {
5902 &self.syntax
5903 }
5904}
5905impl ast::NameOwner for MacroCall {}
5906impl ast::AttrsOwner for MacroCall {}
5907impl ast::DocCommentsOwner for MacroCall {}
5908impl MacroCall {
5909 pub fn token_tree(&self) -> Option<TokenTree> {
5910 AstChildren::new(&self.syntax).next()
5911 }
5912 pub fn path(&self) -> Option<Path> {
5913 AstChildren::new(&self.syntax).next()
5914 }
5915}
5916#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5917pub struct Attr {
5918 pub(crate) syntax: SyntaxNode,
5919}
5920impl std::fmt::Display for Attr {
5921 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5922 std::fmt::Display::fmt(self.syntax(), f)
5923 }
5924}
5925impl AstNode for Attr {
5926 fn can_cast(kind: SyntaxKind) -> bool {
5927 match kind {
5928 ATTR => true,
5929 _ => false,
5930 }
5931 }