aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_syntax/src/ast/generated/nodes.rs
diff options
context:
space:
mode:
Diffstat (limited to 'crates/ra_syntax/src/ast/generated/nodes.rs')
-rw-r--r--crates/ra_syntax/src/ast/generated/nodes.rs552
1 files changed, 347 insertions, 205 deletions
diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs
index 20f663046..0df7cfe52 100644
--- a/crates/ra_syntax/src/ast/generated/nodes.rs
+++ b/crates/ra_syntax/src/ast/generated/nodes.rs
@@ -1,11 +1,11 @@
1//! Generated file, do not edit by hand, see `xtask/src/codegen` 1//! Generated file, do not edit by hand, see `xtask/src/codegen`
2 2
3use super::tokens::*;
4use crate::{ 3use crate::{
5 ast::{self, support, AstChildren, AstNode}, 4 ast::{self, support, AstChildren, AstNode},
6 SyntaxKind::{self, *}, 5 SyntaxKind::{self, *},
7 SyntaxNode, SyntaxToken, 6 SyntaxNode, SyntaxToken, T,
8}; 7};
8
9#[derive(Debug, Clone, PartialEq, Eq, Hash)] 9#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10pub struct SourceFile { 10pub struct SourceFile {
11 pub(crate) syntax: SyntaxNode, 11 pub(crate) syntax: SyntaxNode,
@@ -26,6 +26,7 @@ impl ast::AttrsOwner for SourceFile {}
26impl SourceFile { 26impl SourceFile {
27 pub fn modules(&self) -> AstChildren<Module> { support::children(&self.syntax) } 27 pub fn modules(&self) -> AstChildren<Module> { support::children(&self.syntax) }
28} 28}
29
29#[derive(Debug, Clone, PartialEq, Eq, Hash)] 30#[derive(Debug, Clone, PartialEq, Eq, Hash)]
30pub struct FnDef { 31pub struct FnDef {
31 pub(crate) syntax: SyntaxNode, 32 pub(crate) syntax: SyntaxNode,
@@ -48,16 +49,17 @@ impl ast::DocCommentsOwner for FnDef {}
48impl ast::AttrsOwner for FnDef {} 49impl ast::AttrsOwner for FnDef {}
49impl FnDef { 50impl FnDef {
50 pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) } 51 pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
51 pub fn const_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, CONST_KW) } 52 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
52 pub fn default_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, DEFAULT_KW) } 53 pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
53 pub fn async_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, ASYNC_KW) } 54 pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
54 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, UNSAFE_KW) } 55 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
55 pub fn fn_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, FN_KW) } 56 pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) }
56 pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } 57 pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
57 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } 58 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
58 pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) } 59 pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
59 pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) } 60 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
60} 61}
62
61#[derive(Debug, Clone, PartialEq, Eq, Hash)] 63#[derive(Debug, Clone, PartialEq, Eq, Hash)]
62pub struct RetType { 64pub struct RetType {
63 pub(crate) syntax: SyntaxNode, 65 pub(crate) syntax: SyntaxNode,
@@ -74,9 +76,10 @@ impl AstNode for RetType {
74 fn syntax(&self) -> &SyntaxNode { &self.syntax } 76 fn syntax(&self) -> &SyntaxNode { &self.syntax }
75} 77}
76impl RetType { 78impl RetType {
77 pub fn thin_arrow_token(&self) -> Option<ThinArrow> { support::token(&self.syntax) } 79 pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) }
78 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 80 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
79} 81}
82
80#[derive(Debug, Clone, PartialEq, Eq, Hash)] 83#[derive(Debug, Clone, PartialEq, Eq, Hash)]
81pub struct StructDef { 84pub struct StructDef {
82 pub(crate) syntax: SyntaxNode, 85 pub(crate) syntax: SyntaxNode,
@@ -98,10 +101,11 @@ impl ast::TypeParamsOwner for StructDef {}
98impl ast::AttrsOwner for StructDef {} 101impl ast::AttrsOwner for StructDef {}
99impl ast::DocCommentsOwner for StructDef {} 102impl ast::DocCommentsOwner for StructDef {}
100impl StructDef { 103impl StructDef {
101 pub fn struct_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, STRUCT_KW) } 104 pub fn struct_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![struct]) }
102 pub fn field_def_list(&self) -> Option<FieldDefList> { support::child(&self.syntax) } 105 pub fn field_def_list(&self) -> Option<FieldDefList> { support::child(&self.syntax) }
103 pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) } 106 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
104} 107}
108
105#[derive(Debug, Clone, PartialEq, Eq, Hash)] 109#[derive(Debug, Clone, PartialEq, Eq, Hash)]
106pub struct UnionDef { 110pub struct UnionDef {
107 pub(crate) syntax: SyntaxNode, 111 pub(crate) syntax: SyntaxNode,
@@ -123,11 +127,12 @@ impl ast::TypeParamsOwner for UnionDef {}
123impl ast::AttrsOwner for UnionDef {} 127impl ast::AttrsOwner for UnionDef {}
124impl ast::DocCommentsOwner for UnionDef {} 128impl ast::DocCommentsOwner for UnionDef {}
125impl UnionDef { 129impl UnionDef {
126 pub fn union_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, UNION_KW) } 130 pub fn union_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![union]) }
127 pub fn record_field_def_list(&self) -> Option<RecordFieldDefList> { 131 pub fn record_field_def_list(&self) -> Option<RecordFieldDefList> {
128 support::child(&self.syntax) 132 support::child(&self.syntax)
129 } 133 }
130} 134}
135
131#[derive(Debug, Clone, PartialEq, Eq, Hash)] 136#[derive(Debug, Clone, PartialEq, Eq, Hash)]
132pub struct RecordFieldDefList { 137pub struct RecordFieldDefList {
133 pub(crate) syntax: SyntaxNode, 138 pub(crate) syntax: SyntaxNode,
@@ -144,10 +149,11 @@ impl AstNode for RecordFieldDefList {
144 fn syntax(&self) -> &SyntaxNode { &self.syntax } 149 fn syntax(&self) -> &SyntaxNode { &self.syntax }
145} 150}
146impl RecordFieldDefList { 151impl RecordFieldDefList {
147 pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) } 152 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
148 pub fn fields(&self) -> AstChildren<RecordFieldDef> { support::children(&self.syntax) } 153 pub fn fields(&self) -> AstChildren<RecordFieldDef> { support::children(&self.syntax) }
149 pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) } 154 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
150} 155}
156
151#[derive(Debug, Clone, PartialEq, Eq, Hash)] 157#[derive(Debug, Clone, PartialEq, Eq, Hash)]
152pub struct RecordFieldDef { 158pub struct RecordFieldDef {
153 pub(crate) syntax: SyntaxNode, 159 pub(crate) syntax: SyntaxNode,
@@ -169,6 +175,7 @@ impl ast::AttrsOwner for RecordFieldDef {}
169impl ast::DocCommentsOwner for RecordFieldDef {} 175impl ast::DocCommentsOwner for RecordFieldDef {}
170impl ast::TypeAscriptionOwner for RecordFieldDef {} 176impl ast::TypeAscriptionOwner for RecordFieldDef {}
171impl RecordFieldDef {} 177impl RecordFieldDef {}
178
172#[derive(Debug, Clone, PartialEq, Eq, Hash)] 179#[derive(Debug, Clone, PartialEq, Eq, Hash)]
173pub struct TupleFieldDefList { 180pub struct TupleFieldDefList {
174 pub(crate) syntax: SyntaxNode, 181 pub(crate) syntax: SyntaxNode,
@@ -185,10 +192,11 @@ impl AstNode for TupleFieldDefList {
185 fn syntax(&self) -> &SyntaxNode { &self.syntax } 192 fn syntax(&self) -> &SyntaxNode { &self.syntax }
186} 193}
187impl TupleFieldDefList { 194impl TupleFieldDefList {
188 pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) } 195 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
189 pub fn fields(&self) -> AstChildren<TupleFieldDef> { support::children(&self.syntax) } 196 pub fn fields(&self) -> AstChildren<TupleFieldDef> { support::children(&self.syntax) }
190 pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) } 197 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
191} 198}
199
192#[derive(Debug, Clone, PartialEq, Eq, Hash)] 200#[derive(Debug, Clone, PartialEq, Eq, Hash)]
193pub struct TupleFieldDef { 201pub struct TupleFieldDef {
194 pub(crate) syntax: SyntaxNode, 202 pub(crate) syntax: SyntaxNode,
@@ -209,6 +217,7 @@ impl ast::AttrsOwner for TupleFieldDef {}
209impl TupleFieldDef { 217impl TupleFieldDef {
210 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 218 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
211} 219}
220
212#[derive(Debug, Clone, PartialEq, Eq, Hash)] 221#[derive(Debug, Clone, PartialEq, Eq, Hash)]
213pub struct EnumDef { 222pub struct EnumDef {
214 pub(crate) syntax: SyntaxNode, 223 pub(crate) syntax: SyntaxNode,
@@ -230,9 +239,10 @@ impl ast::TypeParamsOwner for EnumDef {}
230impl ast::AttrsOwner for EnumDef {} 239impl ast::AttrsOwner for EnumDef {}
231impl ast::DocCommentsOwner for EnumDef {} 240impl ast::DocCommentsOwner for EnumDef {}
232impl EnumDef { 241impl EnumDef {
233 pub fn enum_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, ENUM_KW) } 242 pub fn enum_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![enum]) }
234 pub fn variant_list(&self) -> Option<EnumVariantList> { support::child(&self.syntax) } 243 pub fn variant_list(&self) -> Option<EnumVariantList> { support::child(&self.syntax) }
235} 244}
245
236#[derive(Debug, Clone, PartialEq, Eq, Hash)] 246#[derive(Debug, Clone, PartialEq, Eq, Hash)]
237pub struct EnumVariantList { 247pub struct EnumVariantList {
238 pub(crate) syntax: SyntaxNode, 248 pub(crate) syntax: SyntaxNode,
@@ -249,10 +259,11 @@ impl AstNode for EnumVariantList {
249 fn syntax(&self) -> &SyntaxNode { &self.syntax } 259 fn syntax(&self) -> &SyntaxNode { &self.syntax }
250} 260}
251impl EnumVariantList { 261impl EnumVariantList {
252 pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) } 262 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
253 pub fn variants(&self) -> AstChildren<EnumVariant> { support::children(&self.syntax) } 263 pub fn variants(&self) -> AstChildren<EnumVariant> { support::children(&self.syntax) }
254 pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) } 264 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
255} 265}
266
256#[derive(Debug, Clone, PartialEq, Eq, Hash)] 267#[derive(Debug, Clone, PartialEq, Eq, Hash)]
257pub struct EnumVariant { 268pub struct EnumVariant {
258 pub(crate) syntax: SyntaxNode, 269 pub(crate) syntax: SyntaxNode,
@@ -274,9 +285,10 @@ impl ast::DocCommentsOwner for EnumVariant {}
274impl ast::AttrsOwner for EnumVariant {} 285impl ast::AttrsOwner for EnumVariant {}
275impl EnumVariant { 286impl EnumVariant {
276 pub fn field_def_list(&self) -> Option<FieldDefList> { support::child(&self.syntax) } 287 pub fn field_def_list(&self) -> Option<FieldDefList> { support::child(&self.syntax) }
277 pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) } 288 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
278 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 289 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
279} 290}
291
280#[derive(Debug, Clone, PartialEq, Eq, Hash)] 292#[derive(Debug, Clone, PartialEq, Eq, Hash)]
281pub struct TraitDef { 293pub struct TraitDef {
282 pub(crate) syntax: SyntaxNode, 294 pub(crate) syntax: SyntaxNode,
@@ -299,11 +311,12 @@ impl ast::DocCommentsOwner for TraitDef {}
299impl ast::TypeParamsOwner for TraitDef {} 311impl ast::TypeParamsOwner for TraitDef {}
300impl ast::TypeBoundsOwner for TraitDef {} 312impl ast::TypeBoundsOwner for TraitDef {}
301impl TraitDef { 313impl TraitDef {
302 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, UNSAFE_KW) } 314 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
303 pub fn auto_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, AUTO_KW) } 315 pub fn auto_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![auto]) }
304 pub fn trait_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, TRAIT_KW) } 316 pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) }
305 pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) } 317 pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
306} 318}
319
307#[derive(Debug, Clone, PartialEq, Eq, Hash)] 320#[derive(Debug, Clone, PartialEq, Eq, Hash)]
308pub struct Module { 321pub struct Module {
309 pub(crate) syntax: SyntaxNode, 322 pub(crate) syntax: SyntaxNode,
@@ -324,10 +337,11 @@ impl ast::NameOwner for Module {}
324impl ast::AttrsOwner for Module {} 337impl ast::AttrsOwner for Module {}
325impl ast::DocCommentsOwner for Module {} 338impl ast::DocCommentsOwner for Module {}
326impl Module { 339impl Module {
327 pub fn mod_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MOD_KW) } 340 pub fn mod_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mod]) }
328 pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) } 341 pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
329 pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) } 342 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
330} 343}
344
331#[derive(Debug, Clone, PartialEq, Eq, Hash)] 345#[derive(Debug, Clone, PartialEq, Eq, Hash)]
332pub struct ItemList { 346pub struct ItemList {
333 pub(crate) syntax: SyntaxNode, 347 pub(crate) syntax: SyntaxNode,
@@ -345,10 +359,11 @@ impl AstNode for ItemList {
345} 359}
346impl ast::ModuleItemOwner for ItemList {} 360impl ast::ModuleItemOwner for ItemList {}
347impl ItemList { 361impl ItemList {
348 pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) } 362 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
349 pub fn impl_items(&self) -> AstChildren<ImplItem> { support::children(&self.syntax) } 363 pub fn impl_items(&self) -> AstChildren<ImplItem> { support::children(&self.syntax) }
350 pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) } 364 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
351} 365}
366
352#[derive(Debug, Clone, PartialEq, Eq, Hash)] 367#[derive(Debug, Clone, PartialEq, Eq, Hash)]
353pub struct ConstDef { 368pub struct ConstDef {
354 pub(crate) syntax: SyntaxNode, 369 pub(crate) syntax: SyntaxNode,
@@ -371,12 +386,13 @@ impl ast::AttrsOwner for ConstDef {}
371impl ast::DocCommentsOwner for ConstDef {} 386impl ast::DocCommentsOwner for ConstDef {}
372impl ast::TypeAscriptionOwner for ConstDef {} 387impl ast::TypeAscriptionOwner for ConstDef {}
373impl ConstDef { 388impl ConstDef {
374 pub fn default_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, DEFAULT_KW) } 389 pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
375 pub fn const_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, CONST_KW) } 390 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
376 pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) } 391 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
377 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) } 392 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
378 pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) } 393 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
379} 394}
395
380#[derive(Debug, Clone, PartialEq, Eq, Hash)] 396#[derive(Debug, Clone, PartialEq, Eq, Hash)]
381pub struct StaticDef { 397pub struct StaticDef {
382 pub(crate) syntax: SyntaxNode, 398 pub(crate) syntax: SyntaxNode,
@@ -399,12 +415,13 @@ impl ast::AttrsOwner for StaticDef {}
399impl ast::DocCommentsOwner for StaticDef {} 415impl ast::DocCommentsOwner for StaticDef {}
400impl ast::TypeAscriptionOwner for StaticDef {} 416impl ast::TypeAscriptionOwner for StaticDef {}
401impl StaticDef { 417impl StaticDef {
402 pub fn static_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, STATIC_KW) } 418 pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) }
403 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MUT_KW) } 419 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
404 pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) } 420 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
405 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) } 421 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
406 pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) } 422 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
407} 423}
424
408#[derive(Debug, Clone, PartialEq, Eq, Hash)] 425#[derive(Debug, Clone, PartialEq, Eq, Hash)]
409pub struct TypeAliasDef { 426pub struct TypeAliasDef {
410 pub(crate) syntax: SyntaxNode, 427 pub(crate) syntax: SyntaxNode,
@@ -427,12 +444,13 @@ impl ast::AttrsOwner for TypeAliasDef {}
427impl ast::DocCommentsOwner for TypeAliasDef {} 444impl ast::DocCommentsOwner for TypeAliasDef {}
428impl ast::TypeBoundsOwner for TypeAliasDef {} 445impl ast::TypeBoundsOwner for TypeAliasDef {}
429impl TypeAliasDef { 446impl TypeAliasDef {
430 pub fn default_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, DEFAULT_KW) } 447 pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
431 pub fn type_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, TYPE_KW) } 448 pub fn type_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![type]) }
432 pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) } 449 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
433 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 450 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
434 pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) } 451 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
435} 452}
453
436#[derive(Debug, Clone, PartialEq, Eq, Hash)] 454#[derive(Debug, Clone, PartialEq, Eq, Hash)]
437pub struct ImplDef { 455pub struct ImplDef {
438 pub(crate) syntax: SyntaxNode, 456 pub(crate) syntax: SyntaxNode,
@@ -451,14 +469,15 @@ impl AstNode for ImplDef {
451impl ast::TypeParamsOwner for ImplDef {} 469impl ast::TypeParamsOwner for ImplDef {}
452impl ast::AttrsOwner for ImplDef {} 470impl ast::AttrsOwner for ImplDef {}
453impl ImplDef { 471impl ImplDef {
454 pub fn default_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, DEFAULT_KW) } 472 pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
455 pub fn const_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, CONST_KW) } 473 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
456 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, UNSAFE_KW) } 474 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
457 pub fn impl_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, IMPL_KW) } 475 pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
458 pub fn excl_token(&self) -> Option<Excl> { support::token(&self.syntax) } 476 pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
459 pub fn for_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, FOR_KW) } 477 pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
460 pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) } 478 pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
461} 479}
480
462#[derive(Debug, Clone, PartialEq, Eq, Hash)] 481#[derive(Debug, Clone, PartialEq, Eq, Hash)]
463pub struct ParenType { 482pub struct ParenType {
464 pub(crate) syntax: SyntaxNode, 483 pub(crate) syntax: SyntaxNode,
@@ -475,10 +494,11 @@ impl AstNode for ParenType {
475 fn syntax(&self) -> &SyntaxNode { &self.syntax } 494 fn syntax(&self) -> &SyntaxNode { &self.syntax }
476} 495}
477impl ParenType { 496impl ParenType {
478 pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) } 497 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
479 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 498 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
480 pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) } 499 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
481} 500}
501
482#[derive(Debug, Clone, PartialEq, Eq, Hash)] 502#[derive(Debug, Clone, PartialEq, Eq, Hash)]
483pub struct TupleType { 503pub struct TupleType {
484 pub(crate) syntax: SyntaxNode, 504 pub(crate) syntax: SyntaxNode,
@@ -495,10 +515,11 @@ impl AstNode for TupleType {
495 fn syntax(&self) -> &SyntaxNode { &self.syntax } 515 fn syntax(&self) -> &SyntaxNode { &self.syntax }
496} 516}
497impl TupleType { 517impl TupleType {
498 pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) } 518 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
499 pub fn fields(&self) -> AstChildren<TypeRef> { support::children(&self.syntax) } 519 pub fn fields(&self) -> AstChildren<TypeRef> { support::children(&self.syntax) }
500 pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) } 520 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
501} 521}
522
502#[derive(Debug, Clone, PartialEq, Eq, Hash)] 523#[derive(Debug, Clone, PartialEq, Eq, Hash)]
503pub struct NeverType { 524pub struct NeverType {
504 pub(crate) syntax: SyntaxNode, 525 pub(crate) syntax: SyntaxNode,
@@ -515,8 +536,9 @@ impl AstNode for NeverType {
515 fn syntax(&self) -> &SyntaxNode { &self.syntax } 536 fn syntax(&self) -> &SyntaxNode { &self.syntax }
516} 537}
517impl NeverType { 538impl NeverType {
518 pub fn excl_token(&self) -> Option<Excl> { support::token(&self.syntax) } 539 pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
519} 540}
541
520#[derive(Debug, Clone, PartialEq, Eq, Hash)] 542#[derive(Debug, Clone, PartialEq, Eq, Hash)]
521pub struct PathType { 543pub struct PathType {
522 pub(crate) syntax: SyntaxNode, 544 pub(crate) syntax: SyntaxNode,
@@ -535,6 +557,7 @@ impl AstNode for PathType {
535impl PathType { 557impl PathType {
536 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 558 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
537} 559}
560
538#[derive(Debug, Clone, PartialEq, Eq, Hash)] 561#[derive(Debug, Clone, PartialEq, Eq, Hash)]
539pub struct PointerType { 562pub struct PointerType {
540 pub(crate) syntax: SyntaxNode, 563 pub(crate) syntax: SyntaxNode,
@@ -551,11 +574,12 @@ impl AstNode for PointerType {
551 fn syntax(&self) -> &SyntaxNode { &self.syntax } 574 fn syntax(&self) -> &SyntaxNode { &self.syntax }
552} 575}
553impl PointerType { 576impl PointerType {
554 pub fn star_token(&self) -> Option<Star> { support::token(&self.syntax) } 577 pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
555 pub fn const_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, CONST_KW) } 578 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
556 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MUT_KW) } 579 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
557 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 580 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
558} 581}
582
559#[derive(Debug, Clone, PartialEq, Eq, Hash)] 583#[derive(Debug, Clone, PartialEq, Eq, Hash)]
560pub struct ArrayType { 584pub struct ArrayType {
561 pub(crate) syntax: SyntaxNode, 585 pub(crate) syntax: SyntaxNode,
@@ -572,12 +596,13 @@ impl AstNode for ArrayType {
572 fn syntax(&self) -> &SyntaxNode { &self.syntax } 596 fn syntax(&self) -> &SyntaxNode { &self.syntax }
573} 597}
574impl ArrayType { 598impl ArrayType {
575 pub fn l_brack_token(&self) -> Option<LBrack> { support::token(&self.syntax) } 599 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
576 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 600 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
577 pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) } 601 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
578 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 602 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
579 pub fn r_brack_token(&self) -> Option<RBrack> { support::token(&self.syntax) } 603 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
580} 604}
605
581#[derive(Debug, Clone, PartialEq, Eq, Hash)] 606#[derive(Debug, Clone, PartialEq, Eq, Hash)]
582pub struct SliceType { 607pub struct SliceType {
583 pub(crate) syntax: SyntaxNode, 608 pub(crate) syntax: SyntaxNode,
@@ -594,10 +619,11 @@ impl AstNode for SliceType {
594 fn syntax(&self) -> &SyntaxNode { &self.syntax } 619 fn syntax(&self) -> &SyntaxNode { &self.syntax }
595} 620}
596impl SliceType { 621impl SliceType {
597 pub fn l_brack_token(&self) -> Option<LBrack> { support::token(&self.syntax) } 622 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
598 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 623 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
599 pub fn r_brack_token(&self) -> Option<RBrack> { support::token(&self.syntax) } 624 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
600} 625}
626
601#[derive(Debug, Clone, PartialEq, Eq, Hash)] 627#[derive(Debug, Clone, PartialEq, Eq, Hash)]
602pub struct ReferenceType { 628pub struct ReferenceType {
603 pub(crate) syntax: SyntaxNode, 629 pub(crate) syntax: SyntaxNode,
@@ -614,11 +640,14 @@ impl AstNode for ReferenceType {
614 fn syntax(&self) -> &SyntaxNode { &self.syntax } 640 fn syntax(&self) -> &SyntaxNode { &self.syntax }
615} 641}
616impl ReferenceType { 642impl ReferenceType {
617 pub fn amp_token(&self) -> Option<Amp> { support::token(&self.syntax) } 643 pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
618 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) } 644 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
619 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MUT_KW) } 645 support::token(&self.syntax, T![lifetime])
646 }
647 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
620 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 648 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
621} 649}
650
622#[derive(Debug, Clone, PartialEq, Eq, Hash)] 651#[derive(Debug, Clone, PartialEq, Eq, Hash)]
623pub struct PlaceholderType { 652pub struct PlaceholderType {
624 pub(crate) syntax: SyntaxNode, 653 pub(crate) syntax: SyntaxNode,
@@ -635,8 +664,9 @@ impl AstNode for PlaceholderType {
635 fn syntax(&self) -> &SyntaxNode { &self.syntax } 664 fn syntax(&self) -> &SyntaxNode { &self.syntax }
636} 665}
637impl PlaceholderType { 666impl PlaceholderType {
638 pub fn underscore_token(&self) -> Option<Underscore> { support::token(&self.syntax) } 667 pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
639} 668}
669
640#[derive(Debug, Clone, PartialEq, Eq, Hash)] 670#[derive(Debug, Clone, PartialEq, Eq, Hash)]
641pub struct FnPointerType { 671pub struct FnPointerType {
642 pub(crate) syntax: SyntaxNode, 672 pub(crate) syntax: SyntaxNode,
@@ -654,11 +684,12 @@ impl AstNode for FnPointerType {
654} 684}
655impl FnPointerType { 685impl FnPointerType {
656 pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) } 686 pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
657 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, UNSAFE_KW) } 687 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
658 pub fn fn_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, FN_KW) } 688 pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) }
659 pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } 689 pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
660 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } 690 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
661} 691}
692
662#[derive(Debug, Clone, PartialEq, Eq, Hash)] 693#[derive(Debug, Clone, PartialEq, Eq, Hash)]
663pub struct ForType { 694pub struct ForType {
664 pub(crate) syntax: SyntaxNode, 695 pub(crate) syntax: SyntaxNode,
@@ -675,10 +706,11 @@ impl AstNode for ForType {
675 fn syntax(&self) -> &SyntaxNode { &self.syntax } 706 fn syntax(&self) -> &SyntaxNode { &self.syntax }
676} 707}
677impl ForType { 708impl ForType {
678 pub fn for_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, FOR_KW) } 709 pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
679 pub fn type_param_list(&self) -> Option<TypeParamList> { support::child(&self.syntax) } 710 pub fn type_param_list(&self) -> Option<TypeParamList> { support::child(&self.syntax) }
680 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 711 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
681} 712}
713
682#[derive(Debug, Clone, PartialEq, Eq, Hash)] 714#[derive(Debug, Clone, PartialEq, Eq, Hash)]
683pub struct ImplTraitType { 715pub struct ImplTraitType {
684 pub(crate) syntax: SyntaxNode, 716 pub(crate) syntax: SyntaxNode,
@@ -696,8 +728,9 @@ impl AstNode for ImplTraitType {
696} 728}
697impl ast::TypeBoundsOwner for ImplTraitType {} 729impl ast::TypeBoundsOwner for ImplTraitType {}
698impl ImplTraitType { 730impl ImplTraitType {
699 pub fn impl_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, IMPL_KW) } 731 pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
700} 732}
733
701#[derive(Debug, Clone, PartialEq, Eq, Hash)] 734#[derive(Debug, Clone, PartialEq, Eq, Hash)]
702pub struct DynTraitType { 735pub struct DynTraitType {
703 pub(crate) syntax: SyntaxNode, 736 pub(crate) syntax: SyntaxNode,
@@ -715,8 +748,9 @@ impl AstNode for DynTraitType {
715} 748}
716impl ast::TypeBoundsOwner for DynTraitType {} 749impl ast::TypeBoundsOwner for DynTraitType {}
717impl DynTraitType { 750impl DynTraitType {
718 pub fn dyn_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, DYN_KW) } 751 pub fn dyn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![dyn]) }
719} 752}
753
720#[derive(Debug, Clone, PartialEq, Eq, Hash)] 754#[derive(Debug, Clone, PartialEq, Eq, Hash)]
721pub struct TupleExpr { 755pub struct TupleExpr {
722 pub(crate) syntax: SyntaxNode, 756 pub(crate) syntax: SyntaxNode,
@@ -734,10 +768,11 @@ impl AstNode for TupleExpr {
734} 768}
735impl ast::AttrsOwner for TupleExpr {} 769impl ast::AttrsOwner for TupleExpr {}
736impl TupleExpr { 770impl TupleExpr {
737 pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) } 771 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
738 pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) } 772 pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
739 pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) } 773 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
740} 774}
775
741#[derive(Debug, Clone, PartialEq, Eq, Hash)] 776#[derive(Debug, Clone, PartialEq, Eq, Hash)]
742pub struct ArrayExpr { 777pub struct ArrayExpr {
743 pub(crate) syntax: SyntaxNode, 778 pub(crate) syntax: SyntaxNode,
@@ -755,11 +790,12 @@ impl AstNode for ArrayExpr {
755} 790}
756impl ast::AttrsOwner for ArrayExpr {} 791impl ast::AttrsOwner for ArrayExpr {}
757impl ArrayExpr { 792impl ArrayExpr {
758 pub fn l_brack_token(&self) -> Option<LBrack> { support::token(&self.syntax) } 793 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
759 pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) } 794 pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
760 pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) } 795 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
761 pub fn r_brack_token(&self) -> Option<RBrack> { support::token(&self.syntax) } 796 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
762} 797}
798
763#[derive(Debug, Clone, PartialEq, Eq, Hash)] 799#[derive(Debug, Clone, PartialEq, Eq, Hash)]
764pub struct ParenExpr { 800pub struct ParenExpr {
765 pub(crate) syntax: SyntaxNode, 801 pub(crate) syntax: SyntaxNode,
@@ -777,10 +813,11 @@ impl AstNode for ParenExpr {
777} 813}
778impl ast::AttrsOwner for ParenExpr {} 814impl ast::AttrsOwner for ParenExpr {}
779impl ParenExpr { 815impl ParenExpr {
780 pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) } 816 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
781 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 817 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
782 pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) } 818 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
783} 819}
820
784#[derive(Debug, Clone, PartialEq, Eq, Hash)] 821#[derive(Debug, Clone, PartialEq, Eq, Hash)]
785pub struct PathExpr { 822pub struct PathExpr {
786 pub(crate) syntax: SyntaxNode, 823 pub(crate) syntax: SyntaxNode,
@@ -799,6 +836,7 @@ impl AstNode for PathExpr {
799impl PathExpr { 836impl PathExpr {
800 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 837 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
801} 838}
839
802#[derive(Debug, Clone, PartialEq, Eq, Hash)] 840#[derive(Debug, Clone, PartialEq, Eq, Hash)]
803pub struct LambdaExpr { 841pub struct LambdaExpr {
804 pub(crate) syntax: SyntaxNode, 842 pub(crate) syntax: SyntaxNode,
@@ -816,13 +854,14 @@ impl AstNode for LambdaExpr {
816} 854}
817impl ast::AttrsOwner for LambdaExpr {} 855impl ast::AttrsOwner for LambdaExpr {}
818impl LambdaExpr { 856impl LambdaExpr {
819 pub fn static_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, STATIC_KW) } 857 pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) }
820 pub fn async_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, ASYNC_KW) } 858 pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
821 pub fn move_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MOVE_KW) } 859 pub fn move_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![move]) }
822 pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } 860 pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
823 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } 861 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
824 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) } 862 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
825} 863}
864
826#[derive(Debug, Clone, PartialEq, Eq, Hash)] 865#[derive(Debug, Clone, PartialEq, Eq, Hash)]
827pub struct IfExpr { 866pub struct IfExpr {
828 pub(crate) syntax: SyntaxNode, 867 pub(crate) syntax: SyntaxNode,
@@ -840,9 +879,10 @@ impl AstNode for IfExpr {
840} 879}
841impl ast::AttrsOwner for IfExpr {} 880impl ast::AttrsOwner for IfExpr {}
842impl IfExpr { 881impl IfExpr {
843 pub fn if_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, IF_KW) } 882 pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }
844 pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) } 883 pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) }
845} 884}
885
846#[derive(Debug, Clone, PartialEq, Eq, Hash)] 886#[derive(Debug, Clone, PartialEq, Eq, Hash)]
847pub struct LoopExpr { 887pub struct LoopExpr {
848 pub(crate) syntax: SyntaxNode, 888 pub(crate) syntax: SyntaxNode,
@@ -861,8 +901,9 @@ impl AstNode for LoopExpr {
861impl ast::AttrsOwner for LoopExpr {} 901impl ast::AttrsOwner for LoopExpr {}
862impl ast::LoopBodyOwner for LoopExpr {} 902impl ast::LoopBodyOwner for LoopExpr {}
863impl LoopExpr { 903impl LoopExpr {
864 pub fn loop_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, LOOP_KW) } 904 pub fn loop_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![loop]) }
865} 905}
906
866#[derive(Debug, Clone, PartialEq, Eq, Hash)] 907#[derive(Debug, Clone, PartialEq, Eq, Hash)]
867pub struct TryBlockExpr { 908pub struct TryBlockExpr {
868 pub(crate) syntax: SyntaxNode, 909 pub(crate) syntax: SyntaxNode,
@@ -880,9 +921,10 @@ impl AstNode for TryBlockExpr {
880} 921}
881impl ast::AttrsOwner for TryBlockExpr {} 922impl ast::AttrsOwner for TryBlockExpr {}
882impl TryBlockExpr { 923impl TryBlockExpr {
883 pub fn try_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, TRY_KW) } 924 pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) }
884 pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) } 925 pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
885} 926}
927
886#[derive(Debug, Clone, PartialEq, Eq, Hash)] 928#[derive(Debug, Clone, PartialEq, Eq, Hash)]
887pub struct ForExpr { 929pub struct ForExpr {
888 pub(crate) syntax: SyntaxNode, 930 pub(crate) syntax: SyntaxNode,
@@ -901,11 +943,12 @@ impl AstNode for ForExpr {
901impl ast::AttrsOwner for ForExpr {} 943impl ast::AttrsOwner for ForExpr {}
902impl ast::LoopBodyOwner for ForExpr {} 944impl ast::LoopBodyOwner for ForExpr {}
903impl ForExpr { 945impl ForExpr {
904 pub fn for_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, FOR_KW) } 946 pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
905 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 947 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
906 pub fn in_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, IN_KW) } 948 pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
907 pub fn iterable(&self) -> Option<Expr> { support::child(&self.syntax) } 949 pub fn iterable(&self) -> Option<Expr> { support::child(&self.syntax) }
908} 950}
951
909#[derive(Debug, Clone, PartialEq, Eq, Hash)] 952#[derive(Debug, Clone, PartialEq, Eq, Hash)]
910pub struct WhileExpr { 953pub struct WhileExpr {
911 pub(crate) syntax: SyntaxNode, 954 pub(crate) syntax: SyntaxNode,
@@ -924,9 +967,10 @@ impl AstNode for WhileExpr {
924impl ast::AttrsOwner for WhileExpr {} 967impl ast::AttrsOwner for WhileExpr {}
925impl ast::LoopBodyOwner for WhileExpr {} 968impl ast::LoopBodyOwner for WhileExpr {}
926impl WhileExpr { 969impl WhileExpr {
927 pub fn while_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, WHILE_KW) } 970 pub fn while_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![while]) }
928 pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) } 971 pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) }
929} 972}
973
930#[derive(Debug, Clone, PartialEq, Eq, Hash)] 974#[derive(Debug, Clone, PartialEq, Eq, Hash)]
931pub struct ContinueExpr { 975pub struct ContinueExpr {
932 pub(crate) syntax: SyntaxNode, 976 pub(crate) syntax: SyntaxNode,
@@ -945,10 +989,13 @@ impl AstNode for ContinueExpr {
945impl ast::AttrsOwner for ContinueExpr {} 989impl ast::AttrsOwner for ContinueExpr {}
946impl ContinueExpr { 990impl ContinueExpr {
947 pub fn continue_token(&self) -> Option<SyntaxToken> { 991 pub fn continue_token(&self) -> Option<SyntaxToken> {
948 support::token2(&self.syntax, CONTINUE_KW) 992 support::token(&self.syntax, T![continue])
993 }
994 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
995 support::token(&self.syntax, T![lifetime])
949 } 996 }
950 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) }
951} 997}
998
952#[derive(Debug, Clone, PartialEq, Eq, Hash)] 999#[derive(Debug, Clone, PartialEq, Eq, Hash)]
953pub struct BreakExpr { 1000pub struct BreakExpr {
954 pub(crate) syntax: SyntaxNode, 1001 pub(crate) syntax: SyntaxNode,
@@ -966,10 +1013,13 @@ impl AstNode for BreakExpr {
966} 1013}
967impl ast::AttrsOwner for BreakExpr {} 1014impl ast::AttrsOwner for BreakExpr {}
968impl BreakExpr { 1015impl BreakExpr {
969 pub fn break_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, BREAK_KW) } 1016 pub fn break_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![break]) }
970 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) } 1017 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
1018 support::token(&self.syntax, T![lifetime])
1019 }
971 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1020 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
972} 1021}
1022
973#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1023#[derive(Debug, Clone, PartialEq, Eq, Hash)]
974pub struct Label { 1024pub struct Label {
975 pub(crate) syntax: SyntaxNode, 1025 pub(crate) syntax: SyntaxNode,
@@ -986,8 +1036,11 @@ impl AstNode for Label {
986 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1036 fn syntax(&self) -> &SyntaxNode { &self.syntax }
987} 1037}
988impl Label { 1038impl Label {
989 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) } 1039 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
1040 support::token(&self.syntax, T![lifetime])
1041 }
990} 1042}
1043
991#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1044#[derive(Debug, Clone, PartialEq, Eq, Hash)]
992pub struct BlockExpr { 1045pub struct BlockExpr {
993 pub(crate) syntax: SyntaxNode, 1046 pub(crate) syntax: SyntaxNode,
@@ -1006,9 +1059,10 @@ impl AstNode for BlockExpr {
1006impl ast::AttrsOwner for BlockExpr {} 1059impl ast::AttrsOwner for BlockExpr {}
1007impl BlockExpr { 1060impl BlockExpr {
1008 pub fn label(&self) -> Option<Label> { support::child(&self.syntax) } 1061 pub fn label(&self) -> Option<Label> { support::child(&self.syntax) }
1009 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, UNSAFE_KW) } 1062 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
1010 pub fn block(&self) -> Option<Block> { support::child(&self.syntax) } 1063 pub fn block(&self) -> Option<Block> { support::child(&self.syntax) }
1011} 1064}
1065
1012#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1066#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1013pub struct ReturnExpr { 1067pub struct ReturnExpr {
1014 pub(crate) syntax: SyntaxNode, 1068 pub(crate) syntax: SyntaxNode,
@@ -1028,6 +1082,7 @@ impl ast::AttrsOwner for ReturnExpr {}
1028impl ReturnExpr { 1082impl ReturnExpr {
1029 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1083 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1030} 1084}
1085
1031#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1086#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1032pub struct CallExpr { 1087pub struct CallExpr {
1033 pub(crate) syntax: SyntaxNode, 1088 pub(crate) syntax: SyntaxNode,
@@ -1047,6 +1102,7 @@ impl ast::ArgListOwner for CallExpr {}
1047impl CallExpr { 1102impl CallExpr {
1048 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1103 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1049} 1104}
1105
1050#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1106#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1051pub struct MethodCallExpr { 1107pub struct MethodCallExpr {
1052 pub(crate) syntax: SyntaxNode, 1108 pub(crate) syntax: SyntaxNode,
@@ -1066,10 +1122,11 @@ impl ast::AttrsOwner for MethodCallExpr {}
1066impl ast::ArgListOwner for MethodCallExpr {} 1122impl ast::ArgListOwner for MethodCallExpr {}
1067impl MethodCallExpr { 1123impl MethodCallExpr {
1068 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1124 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1069 pub fn dot_token(&self) -> Option<Dot> { support::token(&self.syntax) } 1125 pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
1070 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } 1126 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
1071 pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) } 1127 pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) }
1072} 1128}
1129
1073#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1130#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1074pub struct IndexExpr { 1131pub struct IndexExpr {
1075 pub(crate) syntax: SyntaxNode, 1132 pub(crate) syntax: SyntaxNode,
@@ -1087,9 +1144,10 @@ impl AstNode for IndexExpr {
1087} 1144}
1088impl ast::AttrsOwner for IndexExpr {} 1145impl ast::AttrsOwner for IndexExpr {}
1089impl IndexExpr { 1146impl IndexExpr {
1090 pub fn l_brack_token(&self) -> Option<LBrack> { support::token(&self.syntax) } 1147 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
1091 pub fn r_brack_token(&self) -> Option<RBrack> { support::token(&self.syntax) } 1148 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1092} 1149}
1150
1093#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1151#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1094pub struct FieldExpr { 1152pub struct FieldExpr {
1095 pub(crate) syntax: SyntaxNode, 1153 pub(crate) syntax: SyntaxNode,
@@ -1108,9 +1166,10 @@ impl AstNode for FieldExpr {
1108impl ast::AttrsOwner for FieldExpr {} 1166impl ast::AttrsOwner for FieldExpr {}
1109impl FieldExpr { 1167impl FieldExpr {
1110 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1168 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1111 pub fn dot_token(&self) -> Option<Dot> { support::token(&self.syntax) } 1169 pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
1112 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } 1170 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
1113} 1171}
1172
1114#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1173#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1115pub struct AwaitExpr { 1174pub struct AwaitExpr {
1116 pub(crate) syntax: SyntaxNode, 1175 pub(crate) syntax: SyntaxNode,
@@ -1129,9 +1188,10 @@ impl AstNode for AwaitExpr {
1129impl ast::AttrsOwner for AwaitExpr {} 1188impl ast::AttrsOwner for AwaitExpr {}
1130impl AwaitExpr { 1189impl AwaitExpr {
1131 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1190 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1132 pub fn dot_token(&self) -> Option<Dot> { support::token(&self.syntax) } 1191 pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
1133 pub fn await_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, AWAIT_KW) } 1192 pub fn await_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![await]) }
1134} 1193}
1194
1135#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1195#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1136pub struct TryExpr { 1196pub struct TryExpr {
1137 pub(crate) syntax: SyntaxNode, 1197 pub(crate) syntax: SyntaxNode,
@@ -1149,9 +1209,10 @@ impl AstNode for TryExpr {
1149} 1209}
1150impl ast::AttrsOwner for TryExpr {} 1210impl ast::AttrsOwner for TryExpr {}
1151impl TryExpr { 1211impl TryExpr {
1152 pub fn try_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, TRY_KW) } 1212 pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) }
1153 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1213 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1154} 1214}
1215
1155#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1216#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1156pub struct CastExpr { 1217pub struct CastExpr {
1157 pub(crate) syntax: SyntaxNode, 1218 pub(crate) syntax: SyntaxNode,
@@ -1170,9 +1231,10 @@ impl AstNode for CastExpr {
1170impl ast::AttrsOwner for CastExpr {} 1231impl ast::AttrsOwner for CastExpr {}
1171impl CastExpr { 1232impl CastExpr {
1172 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1233 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1173 pub fn as_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, AS_KW) } 1234 pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
1174 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 1235 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
1175} 1236}
1237
1176#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1238#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1177pub struct RefExpr { 1239pub struct RefExpr {
1178 pub(crate) syntax: SyntaxNode, 1240 pub(crate) syntax: SyntaxNode,
@@ -1190,11 +1252,12 @@ impl AstNode for RefExpr {
1190} 1252}
1191impl ast::AttrsOwner for RefExpr {} 1253impl ast::AttrsOwner for RefExpr {}
1192impl RefExpr { 1254impl RefExpr {
1193 pub fn amp_token(&self) -> Option<Amp> { support::token(&self.syntax) } 1255 pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
1194 pub fn raw_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, RAW_KW) } 1256 pub fn raw_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![raw]) }
1195 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MUT_KW) } 1257 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1196 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1258 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1197} 1259}
1260
1198#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1261#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1199pub struct PrefixExpr { 1262pub struct PrefixExpr {
1200 pub(crate) syntax: SyntaxNode, 1263 pub(crate) syntax: SyntaxNode,
@@ -1212,9 +1275,9 @@ impl AstNode for PrefixExpr {
1212} 1275}
1213impl ast::AttrsOwner for PrefixExpr {} 1276impl ast::AttrsOwner for PrefixExpr {}
1214impl PrefixExpr { 1277impl PrefixExpr {
1215 pub fn prefix_op_token(&self) -> Option<PrefixOp> { support::token(&self.syntax) }
1216 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1278 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1217} 1279}
1280
1218#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1281#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1219pub struct BoxExpr { 1282pub struct BoxExpr {
1220 pub(crate) syntax: SyntaxNode, 1283 pub(crate) syntax: SyntaxNode,
@@ -1232,9 +1295,10 @@ impl AstNode for BoxExpr {
1232} 1295}
1233impl ast::AttrsOwner for BoxExpr {} 1296impl ast::AttrsOwner for BoxExpr {}
1234impl BoxExpr { 1297impl BoxExpr {
1235 pub fn box_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, BOX_KW) } 1298 pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) }
1236 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1299 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1237} 1300}
1301
1238#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1302#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1239pub struct RangeExpr { 1303pub struct RangeExpr {
1240 pub(crate) syntax: SyntaxNode, 1304 pub(crate) syntax: SyntaxNode,
@@ -1251,9 +1315,8 @@ impl AstNode for RangeExpr {
1251 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1315 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1252} 1316}
1253impl ast::AttrsOwner for RangeExpr {} 1317impl ast::AttrsOwner for RangeExpr {}
1254impl RangeExpr { 1318impl RangeExpr {}
1255 pub fn range_op_token(&self) -> Option<RangeOp> { support::token(&self.syntax) } 1319
1256}
1257#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1320#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1258pub struct BinExpr { 1321pub struct BinExpr {
1259 pub(crate) syntax: SyntaxNode, 1322 pub(crate) syntax: SyntaxNode,
@@ -1270,9 +1333,8 @@ impl AstNode for BinExpr {
1270 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1333 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1271} 1334}
1272impl ast::AttrsOwner for BinExpr {} 1335impl ast::AttrsOwner for BinExpr {}
1273impl BinExpr { 1336impl BinExpr {}
1274 pub fn bin_op_token(&self) -> Option<BinOp> { support::token(&self.syntax) } 1337
1275}
1276#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1338#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1277pub struct Literal { 1339pub struct Literal {
1278 pub(crate) syntax: SyntaxNode, 1340 pub(crate) syntax: SyntaxNode,
@@ -1288,9 +1350,8 @@ impl AstNode for Literal {
1288 } 1350 }
1289 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1351 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1290} 1352}
1291impl Literal { 1353impl Literal {}
1292 pub fn literal_token_token(&self) -> Option<LiteralToken> { support::token(&self.syntax) } 1354
1293}
1294#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1355#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1295pub struct MatchExpr { 1356pub struct MatchExpr {
1296 pub(crate) syntax: SyntaxNode, 1357 pub(crate) syntax: SyntaxNode,
@@ -1308,10 +1369,11 @@ impl AstNode for MatchExpr {
1308} 1369}
1309impl ast::AttrsOwner for MatchExpr {} 1370impl ast::AttrsOwner for MatchExpr {}
1310impl MatchExpr { 1371impl MatchExpr {
1311 pub fn match_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MATCH_KW) } 1372 pub fn match_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![match]) }
1312 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1373 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1313 pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) } 1374 pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) }
1314} 1375}
1376
1315#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1377#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1316pub struct MatchArmList { 1378pub struct MatchArmList {
1317 pub(crate) syntax: SyntaxNode, 1379 pub(crate) syntax: SyntaxNode,
@@ -1329,10 +1391,11 @@ impl AstNode for MatchArmList {
1329} 1391}
1330impl ast::AttrsOwner for MatchArmList {} 1392impl ast::AttrsOwner for MatchArmList {}
1331impl MatchArmList { 1393impl MatchArmList {
1332 pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) } 1394 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
1333 pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) } 1395 pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) }
1334 pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) } 1396 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1335} 1397}
1398
1336#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1399#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1337pub struct MatchArm { 1400pub struct MatchArm {
1338 pub(crate) syntax: SyntaxNode, 1401 pub(crate) syntax: SyntaxNode,
@@ -1352,9 +1415,10 @@ impl ast::AttrsOwner for MatchArm {}
1352impl MatchArm { 1415impl MatchArm {
1353 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 1416 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1354 pub fn guard(&self) -> Option<MatchGuard> { support::child(&self.syntax) } 1417 pub fn guard(&self) -> Option<MatchGuard> { support::child(&self.syntax) }
1355 pub fn fat_arrow_token(&self) -> Option<FatArrow> { support::token(&self.syntax) } 1418 pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) }
1356 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1419 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1357} 1420}
1421
1358#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1422#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1359pub struct MatchGuard { 1423pub struct MatchGuard {
1360 pub(crate) syntax: SyntaxNode, 1424 pub(crate) syntax: SyntaxNode,
@@ -1371,9 +1435,10 @@ impl AstNode for MatchGuard {
1371 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1435 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1372} 1436}
1373impl MatchGuard { 1437impl MatchGuard {
1374 pub fn if_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, IF_KW) } 1438 pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }
1375 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1439 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1376} 1440}
1441
1377#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1442#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1378pub struct RecordLit { 1443pub struct RecordLit {
1379 pub(crate) syntax: SyntaxNode, 1444 pub(crate) syntax: SyntaxNode,
@@ -1393,6 +1458,7 @@ impl RecordLit {
1393 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 1458 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1394 pub fn record_field_list(&self) -> Option<RecordFieldList> { support::child(&self.syntax) } 1459 pub fn record_field_list(&self) -> Option<RecordFieldList> { support::child(&self.syntax) }
1395} 1460}
1461
1396#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1462#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1397pub struct RecordFieldList { 1463pub struct RecordFieldList {
1398 pub(crate) syntax: SyntaxNode, 1464 pub(crate) syntax: SyntaxNode,
@@ -1409,12 +1475,13 @@ impl AstNode for RecordFieldList {
1409 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1475 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1410} 1476}
1411impl RecordFieldList { 1477impl RecordFieldList {
1412 pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) } 1478 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
1413 pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) } 1479 pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) }
1414 pub fn dotdot_token(&self) -> Option<Dotdot> { support::token(&self.syntax) } 1480 pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
1415 pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) } 1481 pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) }
1416 pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) } 1482 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1417} 1483}
1484
1418#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1485#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1419pub struct RecordField { 1486pub struct RecordField {
1420 pub(crate) syntax: SyntaxNode, 1487 pub(crate) syntax: SyntaxNode,
@@ -1433,9 +1500,10 @@ impl AstNode for RecordField {
1433impl ast::AttrsOwner for RecordField {} 1500impl ast::AttrsOwner for RecordField {}
1434impl RecordField { 1501impl RecordField {
1435 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } 1502 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
1436 pub fn colon_token(&self) -> Option<Colon> { support::token(&self.syntax) } 1503 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
1437 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1504 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1438} 1505}
1506
1439#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1507#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1440pub struct OrPat { 1508pub struct OrPat {
1441 pub(crate) syntax: SyntaxNode, 1509 pub(crate) syntax: SyntaxNode,
@@ -1454,6 +1522,7 @@ impl AstNode for OrPat {
1454impl OrPat { 1522impl OrPat {
1455 pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) } 1523 pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1456} 1524}
1525
1457#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1526#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1458pub struct ParenPat { 1527pub struct ParenPat {
1459 pub(crate) syntax: SyntaxNode, 1528 pub(crate) syntax: SyntaxNode,
@@ -1470,10 +1539,11 @@ impl AstNode for ParenPat {
1470 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1539 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1471} 1540}
1472impl ParenPat { 1541impl ParenPat {
1473 pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) } 1542 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1474 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 1543 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1475 pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) } 1544 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1476} 1545}
1546
1477#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1547#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1478pub struct RefPat { 1548pub struct RefPat {
1479 pub(crate) syntax: SyntaxNode, 1549 pub(crate) syntax: SyntaxNode,
@@ -1490,10 +1560,11 @@ impl AstNode for RefPat {
1490 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1560 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1491} 1561}
1492impl RefPat { 1562impl RefPat {
1493 pub fn amp_token(&self) -> Option<Amp> { support::token(&self.syntax) } 1563 pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
1494 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MUT_KW) } 1564 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1495 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 1565 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1496} 1566}
1567
1497#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1568#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1498pub struct BoxPat { 1569pub struct BoxPat {
1499 pub(crate) syntax: SyntaxNode, 1570 pub(crate) syntax: SyntaxNode,
@@ -1510,9 +1581,10 @@ impl AstNode for BoxPat {
1510 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1581 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1511} 1582}
1512impl BoxPat { 1583impl BoxPat {
1513 pub fn box_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, BOX_KW) } 1584 pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) }
1514 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 1585 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1515} 1586}
1587
1516#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1588#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1517pub struct BindPat { 1589pub struct BindPat {
1518 pub(crate) syntax: SyntaxNode, 1590 pub(crate) syntax: SyntaxNode,
@@ -1531,11 +1603,12 @@ impl AstNode for BindPat {
1531impl ast::AttrsOwner for BindPat {} 1603impl ast::AttrsOwner for BindPat {}
1532impl ast::NameOwner for BindPat {} 1604impl ast::NameOwner for BindPat {}
1533impl BindPat { 1605impl BindPat {
1534 pub fn ref_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, REF_KW) } 1606 pub fn ref_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ref]) }
1535 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MUT_KW) } 1607 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
1536 pub fn at_token(&self) -> Option<At> { support::token(&self.syntax) } 1608 pub fn at_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![@]) }
1537 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 1609 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1538} 1610}
1611
1539#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1612#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1540pub struct PlaceholderPat { 1613pub struct PlaceholderPat {
1541 pub(crate) syntax: SyntaxNode, 1614 pub(crate) syntax: SyntaxNode,
@@ -1552,8 +1625,9 @@ impl AstNode for PlaceholderPat {
1552 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1625 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1553} 1626}
1554impl PlaceholderPat { 1627impl PlaceholderPat {
1555 pub fn underscore_token(&self) -> Option<Underscore> { support::token(&self.syntax) } 1628 pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
1556} 1629}
1630
1557#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1631#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1558pub struct DotDotPat { 1632pub struct DotDotPat {
1559 pub(crate) syntax: SyntaxNode, 1633 pub(crate) syntax: SyntaxNode,
@@ -1570,8 +1644,9 @@ impl AstNode for DotDotPat {
1570 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1644 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1571} 1645}
1572impl DotDotPat { 1646impl DotDotPat {
1573 pub fn dotdot_token(&self) -> Option<Dotdot> { support::token(&self.syntax) } 1647 pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
1574} 1648}
1649
1575#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1650#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1576pub struct PathPat { 1651pub struct PathPat {
1577 pub(crate) syntax: SyntaxNode, 1652 pub(crate) syntax: SyntaxNode,
@@ -1590,6 +1665,7 @@ impl AstNode for PathPat {
1590impl PathPat { 1665impl PathPat {
1591 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 1666 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1592} 1667}
1668
1593#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1669#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1594pub struct SlicePat { 1670pub struct SlicePat {
1595 pub(crate) syntax: SyntaxNode, 1671 pub(crate) syntax: SyntaxNode,
@@ -1606,10 +1682,11 @@ impl AstNode for SlicePat {
1606 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1682 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1607} 1683}
1608impl SlicePat { 1684impl SlicePat {
1609 pub fn l_brack_token(&self) -> Option<LBrack> { support::token(&self.syntax) } 1685 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
1610 pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) } 1686 pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1611 pub fn r_brack_token(&self) -> Option<RBrack> { support::token(&self.syntax) } 1687 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1612} 1688}
1689
1613#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1690#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1614pub struct RangePat { 1691pub struct RangePat {
1615 pub(crate) syntax: SyntaxNode, 1692 pub(crate) syntax: SyntaxNode,
@@ -1625,9 +1702,8 @@ impl AstNode for RangePat {
1625 } 1702 }
1626 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1703 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1627} 1704}
1628impl RangePat { 1705impl RangePat {}
1629 pub fn range_separator_token(&self) -> Option<RangeSeparator> { support::token(&self.syntax) } 1706
1630}
1631#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1707#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1632pub struct LiteralPat { 1708pub struct LiteralPat {
1633 pub(crate) syntax: SyntaxNode, 1709 pub(crate) syntax: SyntaxNode,
@@ -1646,6 +1722,7 @@ impl AstNode for LiteralPat {
1646impl LiteralPat { 1722impl LiteralPat {
1647 pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) } 1723 pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
1648} 1724}
1725
1649#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1726#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1650pub struct MacroPat { 1727pub struct MacroPat {
1651 pub(crate) syntax: SyntaxNode, 1728 pub(crate) syntax: SyntaxNode,
@@ -1664,6 +1741,7 @@ impl AstNode for MacroPat {
1664impl MacroPat { 1741impl MacroPat {
1665 pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) } 1742 pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
1666} 1743}
1744
1667#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1745#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1668pub struct RecordPat { 1746pub struct RecordPat {
1669 pub(crate) syntax: SyntaxNode, 1747 pub(crate) syntax: SyntaxNode,
@@ -1685,6 +1763,7 @@ impl RecordPat {
1685 } 1763 }
1686 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 1764 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1687} 1765}
1766
1688#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1767#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1689pub struct RecordFieldPatList { 1768pub struct RecordFieldPatList {
1690 pub(crate) syntax: SyntaxNode, 1769 pub(crate) syntax: SyntaxNode,
@@ -1701,15 +1780,16 @@ impl AstNode for RecordFieldPatList {
1701 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1780 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1702} 1781}
1703impl RecordFieldPatList { 1782impl RecordFieldPatList {
1704 pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) } 1783 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
1705 pub fn pats(&self) -> AstChildren<RecordInnerPat> { support::children(&self.syntax) } 1784 pub fn pats(&self) -> AstChildren<RecordInnerPat> { support::children(&self.syntax) }
1706 pub fn record_field_pats(&self) -> AstChildren<RecordFieldPat> { 1785 pub fn record_field_pats(&self) -> AstChildren<RecordFieldPat> {
1707 support::children(&self.syntax) 1786 support::children(&self.syntax)
1708 } 1787 }
1709 pub fn bind_pats(&self) -> AstChildren<BindPat> { support::children(&self.syntax) } 1788 pub fn bind_pats(&self) -> AstChildren<BindPat> { support::children(&self.syntax) }
1710 pub fn dotdot_token(&self) -> Option<Dotdot> { support::token(&self.syntax) } 1789 pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
1711 pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) } 1790 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1712} 1791}
1792
1713#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1793#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1714pub struct RecordFieldPat { 1794pub struct RecordFieldPat {
1715 pub(crate) syntax: SyntaxNode, 1795 pub(crate) syntax: SyntaxNode,
@@ -1728,9 +1808,10 @@ impl AstNode for RecordFieldPat {
1728impl ast::AttrsOwner for RecordFieldPat {} 1808impl ast::AttrsOwner for RecordFieldPat {}
1729impl ast::NameOwner for RecordFieldPat {} 1809impl ast::NameOwner for RecordFieldPat {}
1730impl RecordFieldPat { 1810impl RecordFieldPat {
1731 pub fn colon_token(&self) -> Option<Colon> { support::token(&self.syntax) } 1811 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
1732 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 1812 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1733} 1813}
1814
1734#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1815#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1735pub struct TupleStructPat { 1816pub struct TupleStructPat {
1736 pub(crate) syntax: SyntaxNode, 1817 pub(crate) syntax: SyntaxNode,
@@ -1748,10 +1829,11 @@ impl AstNode for TupleStructPat {
1748} 1829}
1749impl TupleStructPat { 1830impl TupleStructPat {
1750 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 1831 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1751 pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) } 1832 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1752 pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) } 1833 pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1753 pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) } 1834 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1754} 1835}
1836
1755#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1837#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1756pub struct TuplePat { 1838pub struct TuplePat {
1757 pub(crate) syntax: SyntaxNode, 1839 pub(crate) syntax: SyntaxNode,
@@ -1768,10 +1850,11 @@ impl AstNode for TuplePat {
1768 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1850 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1769} 1851}
1770impl TuplePat { 1852impl TuplePat {
1771 pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) } 1853 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
1772 pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) } 1854 pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
1773 pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) } 1855 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1774} 1856}
1857
1775#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1858#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1776pub struct Visibility { 1859pub struct Visibility {
1777 pub(crate) syntax: SyntaxNode, 1860 pub(crate) syntax: SyntaxNode,
@@ -1788,11 +1871,12 @@ impl AstNode for Visibility {
1788 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1871 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1789} 1872}
1790impl Visibility { 1873impl Visibility {
1791 pub fn pub_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, PUB_KW) } 1874 pub fn pub_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![pub]) }
1792 pub fn super_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, SUPER_KW) } 1875 pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }
1793 pub fn self_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, SELF_KW) } 1876 pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
1794 pub fn crate_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, CRATE_KW) } 1877 pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
1795} 1878}
1879
1796#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1880#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1797pub struct Name { 1881pub struct Name {
1798 pub(crate) syntax: SyntaxNode, 1882 pub(crate) syntax: SyntaxNode,
@@ -1809,8 +1893,9 @@ impl AstNode for Name {
1809 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1893 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1810} 1894}
1811impl Name { 1895impl Name {
1812 pub fn ident_token(&self) -> Option<Ident> { support::token(&self.syntax) } 1896 pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
1813} 1897}
1898
1814#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1899#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1815pub struct NameRef { 1900pub struct NameRef {
1816 pub(crate) syntax: SyntaxNode, 1901 pub(crate) syntax: SyntaxNode,
@@ -1826,9 +1911,8 @@ impl AstNode for NameRef {
1826 } 1911 }
1827 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1912 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1828} 1913}
1829impl NameRef { 1914impl NameRef {}
1830 pub fn name_ref_token_token(&self) -> Option<NameRefToken> { support::token(&self.syntax) } 1915
1831}
1832#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1916#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1833pub struct MacroCall { 1917pub struct MacroCall {
1834 pub(crate) syntax: SyntaxNode, 1918 pub(crate) syntax: SyntaxNode,
@@ -1849,10 +1933,11 @@ impl ast::AttrsOwner for MacroCall {}
1849impl ast::DocCommentsOwner for MacroCall {} 1933impl ast::DocCommentsOwner for MacroCall {}
1850impl MacroCall { 1934impl MacroCall {
1851 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 1935 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1852 pub fn excl_token(&self) -> Option<Excl> { support::token(&self.syntax) } 1936 pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
1853 pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) } 1937 pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
1854 pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) } 1938 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
1855} 1939}
1940
1856#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1941#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1857pub struct Attr { 1942pub struct Attr {
1858 pub(crate) syntax: SyntaxNode, 1943 pub(crate) syntax: SyntaxNode,
@@ -1869,14 +1954,15 @@ impl AstNode for Attr {
1869 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1954 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1870} 1955}
1871impl Attr { 1956impl Attr {
1872 pub fn pound_token(&self) -> Option<Pound> { support::token(&self.syntax) } 1957 pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
1873 pub fn excl_token(&self) -> Option<Excl> { support::token(&self.syntax) } 1958 pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
1874 pub fn l_brack_token(&self) -> Option<LBrack> { support::token(&self.syntax) } 1959 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
1875 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 1960 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1876 pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) } 1961 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
1877 pub fn input(&self) -> Option<AttrInput> { support::child(&self.syntax) } 1962 pub fn input(&self) -> Option<AttrInput> { support::child(&self.syntax) }
1878 pub fn r_brack_token(&self) -> Option<RBrack> { support::token(&self.syntax) } 1963 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
1879} 1964}
1965
1880#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1966#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1881pub struct TokenTree { 1967pub struct TokenTree {
1882 pub(crate) syntax: SyntaxNode, 1968 pub(crate) syntax: SyntaxNode,
@@ -1893,6 +1979,7 @@ impl AstNode for TokenTree {
1893 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1979 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1894} 1980}
1895impl TokenTree {} 1981impl TokenTree {}
1982
1896#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1983#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1897pub struct TypeParamList { 1984pub struct TypeParamList {
1898 pub(crate) syntax: SyntaxNode, 1985 pub(crate) syntax: SyntaxNode,
@@ -1909,13 +1996,14 @@ impl AstNode for TypeParamList {
1909 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1996 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1910} 1997}
1911impl TypeParamList { 1998impl TypeParamList {
1912 pub fn l_angle_token(&self) -> Option<LAngle> { support::token(&self.syntax) } 1999 pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
1913 pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) } 2000 pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) }
1914 pub fn type_params(&self) -> AstChildren<TypeParam> { support::children(&self.syntax) } 2001 pub fn type_params(&self) -> AstChildren<TypeParam> { support::children(&self.syntax) }
1915 pub fn lifetime_params(&self) -> AstChildren<LifetimeParam> { support::children(&self.syntax) } 2002 pub fn lifetime_params(&self) -> AstChildren<LifetimeParam> { support::children(&self.syntax) }
1916 pub fn const_params(&self) -> AstChildren<ConstParam> { support::children(&self.syntax) } 2003 pub fn const_params(&self) -> AstChildren<ConstParam> { support::children(&self.syntax) }
1917 pub fn r_angle_token(&self) -> Option<RAngle> { support::token(&self.syntax) } 2004 pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
1918} 2005}
2006
1919#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2007#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1920pub struct TypeParam { 2008pub struct TypeParam {
1921 pub(crate) syntax: SyntaxNode, 2009 pub(crate) syntax: SyntaxNode,
@@ -1935,9 +2023,10 @@ impl ast::NameOwner for TypeParam {}
1935impl ast::AttrsOwner for TypeParam {} 2023impl ast::AttrsOwner for TypeParam {}
1936impl ast::TypeBoundsOwner for TypeParam {} 2024impl ast::TypeBoundsOwner for TypeParam {}
1937impl TypeParam { 2025impl TypeParam {
1938 pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) } 2026 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
1939 pub fn default_type(&self) -> Option<TypeRef> { support::child(&self.syntax) } 2027 pub fn default_type(&self) -> Option<TypeRef> { support::child(&self.syntax) }
1940} 2028}
2029
1941#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2030#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1942pub struct ConstParam { 2031pub struct ConstParam {
1943 pub(crate) syntax: SyntaxNode, 2032 pub(crate) syntax: SyntaxNode,
@@ -1957,9 +2046,10 @@ impl ast::NameOwner for ConstParam {}
1957impl ast::AttrsOwner for ConstParam {} 2046impl ast::AttrsOwner for ConstParam {}
1958impl ast::TypeAscriptionOwner for ConstParam {} 2047impl ast::TypeAscriptionOwner for ConstParam {}
1959impl ConstParam { 2048impl ConstParam {
1960 pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) } 2049 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
1961 pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) } 2050 pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) }
1962} 2051}
2052
1963#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2053#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1964pub struct LifetimeParam { 2054pub struct LifetimeParam {
1965 pub(crate) syntax: SyntaxNode, 2055 pub(crate) syntax: SyntaxNode,
@@ -1977,8 +2067,11 @@ impl AstNode for LifetimeParam {
1977} 2067}
1978impl ast::AttrsOwner for LifetimeParam {} 2068impl ast::AttrsOwner for LifetimeParam {}
1979impl LifetimeParam { 2069impl LifetimeParam {
1980 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) } 2070 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
2071 support::token(&self.syntax, T![lifetime])
2072 }
1981} 2073}
2074
1982#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2075#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1983pub struct TypeBound { 2076pub struct TypeBound {
1984 pub(crate) syntax: SyntaxNode, 2077 pub(crate) syntax: SyntaxNode,
@@ -1995,10 +2088,13 @@ impl AstNode for TypeBound {
1995 fn syntax(&self) -> &SyntaxNode { &self.syntax } 2088 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1996} 2089}
1997impl TypeBound { 2090impl TypeBound {
1998 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) } 2091 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
1999 pub fn const_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, CONST_KW) } 2092 support::token(&self.syntax, T![lifetime])
2093 }
2094 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
2000 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 2095 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
2001} 2096}
2097
2002#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2098#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2003pub struct TypeBoundList { 2099pub struct TypeBoundList {
2004 pub(crate) syntax: SyntaxNode, 2100 pub(crate) syntax: SyntaxNode,
@@ -2017,6 +2113,7 @@ impl AstNode for TypeBoundList {
2017impl TypeBoundList { 2113impl TypeBoundList {
2018 pub fn bounds(&self) -> AstChildren<TypeBound> { support::children(&self.syntax) } 2114 pub fn bounds(&self) -> AstChildren<TypeBound> { support::children(&self.syntax) }
2019} 2115}
2116
2020#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2117#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2021pub struct WherePred { 2118pub struct WherePred {
2022 pub(crate) syntax: SyntaxNode, 2119 pub(crate) syntax: SyntaxNode,
@@ -2034,9 +2131,12 @@ impl AstNode for WherePred {
2034} 2131}
2035impl ast::TypeBoundsOwner for WherePred {} 2132impl ast::TypeBoundsOwner for WherePred {}
2036impl WherePred { 2133impl WherePred {
2037 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) } 2134 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
2135 support::token(&self.syntax, T![lifetime])
2136 }
2038 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 2137 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
2039} 2138}
2139
2040#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2140#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2041pub struct WhereClause { 2141pub struct WhereClause {
2042 pub(crate) syntax: SyntaxNode, 2142 pub(crate) syntax: SyntaxNode,
@@ -2053,9 +2153,10 @@ impl AstNode for WhereClause {
2053 fn syntax(&self) -> &SyntaxNode { &self.syntax } 2153 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2054} 2154}
2055impl WhereClause { 2155impl WhereClause {
2056 pub fn where_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, WHERE_KW) } 2156 pub fn where_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![where]) }
2057 pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) } 2157 pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) }
2058} 2158}
2159
2059#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2160#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2060pub struct Abi { 2161pub struct Abi {
2061 pub(crate) syntax: SyntaxNode, 2162 pub(crate) syntax: SyntaxNode,
@@ -2071,9 +2172,8 @@ impl AstNode for Abi {
2071 } 2172 }
2072 fn syntax(&self) -> &SyntaxNode { &self.syntax } 2173 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2073} 2174}
2074impl Abi { 2175impl Abi {}
2075 pub fn string_token(&self) -> Option<String> { support::token(&self.syntax) } 2176
2076}
2077#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2177#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2078pub struct ExprStmt { 2178pub struct ExprStmt {
2079 pub(crate) syntax: SyntaxNode, 2179 pub(crate) syntax: SyntaxNode,
@@ -2092,8 +2192,9 @@ impl AstNode for ExprStmt {
2092impl ast::AttrsOwner for ExprStmt {} 2192impl ast::AttrsOwner for ExprStmt {}
2093impl ExprStmt { 2193impl ExprStmt {
2094 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 2194 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
2095 pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) } 2195 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
2096} 2196}
2197
2097#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2198#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2098pub struct LetStmt { 2199pub struct LetStmt {
2099 pub(crate) syntax: SyntaxNode, 2200 pub(crate) syntax: SyntaxNode,
@@ -2112,12 +2213,13 @@ impl AstNode for LetStmt {
2112impl ast::AttrsOwner for LetStmt {} 2213impl ast::AttrsOwner for LetStmt {}
2113impl ast::TypeAscriptionOwner for LetStmt {} 2214impl ast::TypeAscriptionOwner for LetStmt {}
2114impl LetStmt { 2215impl LetStmt {
2115 pub fn let_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, LET_KW) } 2216 pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }
2116 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 2217 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
2117 pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) } 2218 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
2118 pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) } 2219 pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) }
2119 pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) } 2220 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
2120} 2221}
2222
2121#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2223#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2122pub struct Condition { 2224pub struct Condition {
2123 pub(crate) syntax: SyntaxNode, 2225 pub(crate) syntax: SyntaxNode,
@@ -2134,11 +2236,12 @@ impl AstNode for Condition {
2134 fn syntax(&self) -> &SyntaxNode { &self.syntax } 2236 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2135} 2237}
2136impl Condition { 2238impl Condition {
2137 pub fn let_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, LET_KW) } 2239 pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }
2138 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 2240 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
2139 pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) } 2241 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
2140 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 2242 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
2141} 2243}
2244
2142#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2245#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2143pub struct Block { 2246pub struct Block {
2144 pub(crate) syntax: SyntaxNode, 2247 pub(crate) syntax: SyntaxNode,
@@ -2157,11 +2260,12 @@ impl AstNode for Block {
2157impl ast::AttrsOwner for Block {} 2260impl ast::AttrsOwner for Block {}
2158impl ast::ModuleItemOwner for Block {} 2261impl ast::ModuleItemOwner for Block {}
2159impl Block { 2262impl Block {
2160 pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) } 2263 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
2161 pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) } 2264 pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
2162 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 2265 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
2163 pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) } 2266 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
2164} 2267}
2268
2165#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2269#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2166pub struct ParamList { 2270pub struct ParamList {
2167 pub(crate) syntax: SyntaxNode, 2271 pub(crate) syntax: SyntaxNode,
@@ -2178,11 +2282,12 @@ impl AstNode for ParamList {
2178 fn syntax(&self) -> &SyntaxNode { &self.syntax } 2282 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2179} 2283}
2180impl ParamList { 2284impl ParamList {
2181 pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) } 2285 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
2182 pub fn self_param(&self) -> Option<SelfParam> { support::child(&self.syntax) } 2286 pub fn self_param(&self) -> Option<SelfParam> { support::child(&self.syntax) }
2183 pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) } 2287 pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) }
2184 pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) } 2288 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
2185} 2289}
2290
2186#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2291#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2187pub struct SelfParam { 2292pub struct SelfParam {
2188 pub(crate) syntax: SyntaxNode, 2293 pub(crate) syntax: SyntaxNode,
@@ -2201,10 +2306,13 @@ impl AstNode for SelfParam {
2201impl ast::TypeAscriptionOwner for SelfParam {} 2306impl ast::TypeAscriptionOwner for SelfParam {}
2202impl ast::AttrsOwner for SelfParam {} 2307impl ast::AttrsOwner for SelfParam {}
2203impl SelfParam { 2308impl SelfParam {
2204 pub fn amp_token(&self) -> Option<Amp> { support::token(&self.syntax) } 2309 pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
2205 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) } 2310 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
2206 pub fn self_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, SELF_KW) } 2311 support::token(&self.syntax, T![lifetime])
2312 }
2313 pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
2207} 2314}
2315
2208#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2316#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2209pub struct Param { 2317pub struct Param {
2210 pub(crate) syntax: SyntaxNode, 2318 pub(crate) syntax: SyntaxNode,
@@ -2224,8 +2332,9 @@ impl ast::TypeAscriptionOwner for Param {}
2224impl ast::AttrsOwner for Param {} 2332impl ast::AttrsOwner for Param {}
2225impl Param { 2333impl Param {
2226 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 2334 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
2227 pub fn dotdotdot_token(&self) -> Option<Dotdotdot> { support::token(&self.syntax) } 2335 pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) }
2228} 2336}
2337
2229#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2338#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2230pub struct UseItem { 2339pub struct UseItem {
2231 pub(crate) syntax: SyntaxNode, 2340 pub(crate) syntax: SyntaxNode,
@@ -2244,9 +2353,10 @@ impl AstNode for UseItem {
2244impl ast::AttrsOwner for UseItem {} 2353impl ast::AttrsOwner for UseItem {}
2245impl ast::VisibilityOwner for UseItem {} 2354impl ast::VisibilityOwner for UseItem {}
2246impl UseItem { 2355impl UseItem {
2247 pub fn use_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, USE_KW) } 2356 pub fn use_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![use]) }
2248 pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) } 2357 pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) }
2249} 2358}
2359
2250#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2360#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2251pub struct UseTree { 2361pub struct UseTree {
2252 pub(crate) syntax: SyntaxNode, 2362 pub(crate) syntax: SyntaxNode,
@@ -2264,10 +2374,11 @@ impl AstNode for UseTree {
2264} 2374}
2265impl UseTree { 2375impl UseTree {
2266 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 2376 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
2267 pub fn star_token(&self) -> Option<Star> { support::token(&self.syntax) } 2377 pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
2268 pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) } 2378 pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) }
2269 pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) } 2379 pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) }
2270} 2380}
2381
2271#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2382#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2272pub struct Alias { 2383pub struct Alias {
2273 pub(crate) syntax: SyntaxNode, 2384 pub(crate) syntax: SyntaxNode,
@@ -2285,8 +2396,9 @@ impl AstNode for Alias {
2285} 2396}
2286impl ast::NameOwner for Alias {} 2397impl ast::NameOwner for Alias {}
2287impl Alias { 2398impl Alias {
2288 pub fn as_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, AS_KW) } 2399 pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
2289} 2400}
2401
2290#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2402#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2291pub struct UseTreeList { 2403pub struct UseTreeList {
2292 pub(crate) syntax: SyntaxNode, 2404 pub(crate) syntax: SyntaxNode,
@@ -2303,10 +2415,11 @@ impl AstNode for UseTreeList {
2303 fn syntax(&self) -> &SyntaxNode { &self.syntax } 2415 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2304} 2416}
2305impl UseTreeList { 2417impl UseTreeList {
2306 pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) } 2418 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
2307 pub fn use_trees(&self) -> AstChildren<UseTree> { support::children(&self.syntax) } 2419 pub fn use_trees(&self) -> AstChildren<UseTree> { support::children(&self.syntax) }
2308 pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) } 2420 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
2309} 2421}
2422
2310#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2423#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2311pub struct ExternCrateItem { 2424pub struct ExternCrateItem {
2312 pub(crate) syntax: SyntaxNode, 2425 pub(crate) syntax: SyntaxNode,
@@ -2325,11 +2438,12 @@ impl AstNode for ExternCrateItem {
2325impl ast::AttrsOwner for ExternCrateItem {} 2438impl ast::AttrsOwner for ExternCrateItem {}
2326impl ast::VisibilityOwner for ExternCrateItem {} 2439impl ast::VisibilityOwner for ExternCrateItem {}
2327impl ExternCrateItem { 2440impl ExternCrateItem {
2328 pub fn extern_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, EXTERN_KW) } 2441 pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }
2329 pub fn crate_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, CRATE_KW) } 2442 pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
2330 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } 2443 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
2331 pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) } 2444 pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) }
2332} 2445}
2446
2333#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2447#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2334pub struct ArgList { 2448pub struct ArgList {
2335 pub(crate) syntax: SyntaxNode, 2449 pub(crate) syntax: SyntaxNode,
@@ -2346,10 +2460,11 @@ impl AstNode for ArgList {
2346 fn syntax(&self) -> &SyntaxNode { &self.syntax } 2460 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2347} 2461}
2348impl ArgList { 2462impl ArgList {
2349 pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) } 2463 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
2350 pub fn args(&self) -> AstChildren<Expr> { support::children(&self.syntax) } 2464 pub fn args(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
2351 pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) } 2465 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
2352} 2466}
2467
2353#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2468#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2354pub struct Path { 2469pub struct Path {
2355 pub(crate) syntax: SyntaxNode, 2470 pub(crate) syntax: SyntaxNode,
@@ -2369,6 +2484,7 @@ impl Path {
2369 pub fn segment(&self) -> Option<PathSegment> { support::child(&self.syntax) } 2484 pub fn segment(&self) -> Option<PathSegment> { support::child(&self.syntax) }
2370 pub fn qualifier(&self) -> Option<Path> { support::child(&self.syntax) } 2485 pub fn qualifier(&self) -> Option<Path> { support::child(&self.syntax) }
2371} 2486}
2487
2372#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2488#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2373pub struct PathSegment { 2489pub struct PathSegment {
2374 pub(crate) syntax: SyntaxNode, 2490 pub(crate) syntax: SyntaxNode,
@@ -2385,15 +2501,16 @@ impl AstNode for PathSegment {
2385 fn syntax(&self) -> &SyntaxNode { &self.syntax } 2501 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2386} 2502}
2387impl PathSegment { 2503impl PathSegment {
2388 pub fn coloncolon_token(&self) -> Option<Coloncolon> { support::token(&self.syntax) } 2504 pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
2389 pub fn l_angle_token(&self) -> Option<LAngle> { support::token(&self.syntax) } 2505 pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
2390 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } 2506 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
2391 pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) } 2507 pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) }
2392 pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } 2508 pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
2393 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } 2509 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
2394 pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) } 2510 pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) }
2395 pub fn r_angle_token(&self) -> Option<RAngle> { support::token(&self.syntax) } 2511 pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
2396} 2512}
2513
2397#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2514#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2398pub struct TypeArgList { 2515pub struct TypeArgList {
2399 pub(crate) syntax: SyntaxNode, 2516 pub(crate) syntax: SyntaxNode,
@@ -2410,15 +2527,16 @@ impl AstNode for TypeArgList {
2410 fn syntax(&self) -> &SyntaxNode { &self.syntax } 2527 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2411} 2528}
2412impl TypeArgList { 2529impl TypeArgList {
2413 pub fn coloncolon_token(&self) -> Option<Coloncolon> { support::token(&self.syntax) } 2530 pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
2414 pub fn l_angle_token(&self) -> Option<LAngle> { support::token(&self.syntax) } 2531 pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
2415 pub fn generic_args(&self) -> AstChildren<GenericArg> { support::children(&self.syntax) } 2532 pub fn generic_args(&self) -> AstChildren<GenericArg> { support::children(&self.syntax) }
2416 pub fn type_args(&self) -> AstChildren<TypeArg> { support::children(&self.syntax) } 2533 pub fn type_args(&self) -> AstChildren<TypeArg> { support::children(&self.syntax) }
2417 pub fn lifetime_args(&self) -> AstChildren<LifetimeArg> { support::children(&self.syntax) } 2534 pub fn lifetime_args(&self) -> AstChildren<LifetimeArg> { support::children(&self.syntax) }
2418 pub fn assoc_type_args(&self) -> AstChildren<AssocTypeArg> { support::children(&self.syntax) } 2535 pub fn assoc_type_args(&self) -> AstChildren<AssocTypeArg> { support::children(&self.syntax) }
2419 pub fn const_args(&self) -> AstChildren<ConstArg> { support::children(&self.syntax) } 2536 pub fn const_args(&self) -> AstChildren<ConstArg> { support::children(&self.syntax) }
2420 pub fn r_angle_token(&self) -> Option<RAngle> { support::token(&self.syntax) } 2537 pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
2421} 2538}
2539
2422#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2540#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2423pub struct TypeArg { 2541pub struct TypeArg {
2424 pub(crate) syntax: SyntaxNode, 2542 pub(crate) syntax: SyntaxNode,
@@ -2437,6 +2555,7 @@ impl AstNode for TypeArg {
2437impl TypeArg { 2555impl TypeArg {
2438 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 2556 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
2439} 2557}
2558
2440#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2559#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2441pub struct AssocTypeArg { 2560pub struct AssocTypeArg {
2442 pub(crate) syntax: SyntaxNode, 2561 pub(crate) syntax: SyntaxNode,
@@ -2455,9 +2574,10 @@ impl AstNode for AssocTypeArg {
2455impl ast::TypeBoundsOwner for AssocTypeArg {} 2574impl ast::TypeBoundsOwner for AssocTypeArg {}
2456impl AssocTypeArg { 2575impl AssocTypeArg {
2457 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } 2576 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
2458 pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) } 2577 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
2459 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 2578 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
2460} 2579}
2580
2461#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2581#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2462pub struct LifetimeArg { 2582pub struct LifetimeArg {
2463 pub(crate) syntax: SyntaxNode, 2583 pub(crate) syntax: SyntaxNode,
@@ -2474,8 +2594,11 @@ impl AstNode for LifetimeArg {
2474 fn syntax(&self) -> &SyntaxNode { &self.syntax } 2594 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2475} 2595}
2476impl LifetimeArg { 2596impl LifetimeArg {
2477 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) } 2597 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
2598 support::token(&self.syntax, T![lifetime])
2599 }
2478} 2600}
2601
2479#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2602#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2480pub struct ConstArg { 2603pub struct ConstArg {
2481 pub(crate) syntax: SyntaxNode, 2604 pub(crate) syntax: SyntaxNode,
@@ -2493,9 +2616,10 @@ impl AstNode for ConstArg {
2493} 2616}
2494impl ConstArg { 2617impl ConstArg {
2495 pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) } 2618 pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
2496 pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) } 2619 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
2497 pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) } 2620 pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
2498} 2621}
2622
2499#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2623#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2500pub struct MacroItems { 2624pub struct MacroItems {
2501 pub(crate) syntax: SyntaxNode, 2625 pub(crate) syntax: SyntaxNode,
@@ -2513,6 +2637,7 @@ impl AstNode for MacroItems {
2513} 2637}
2514impl ast::ModuleItemOwner for MacroItems {} 2638impl ast::ModuleItemOwner for MacroItems {}
2515impl MacroItems {} 2639impl MacroItems {}
2640
2516#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2641#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2517pub struct MacroStmts { 2642pub struct MacroStmts {
2518 pub(crate) syntax: SyntaxNode, 2643 pub(crate) syntax: SyntaxNode,
@@ -2532,6 +2657,7 @@ impl MacroStmts {
2532 pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) } 2657 pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
2533 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 2658 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
2534} 2659}
2660
2535#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2661#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2536pub struct ExternItemList { 2662pub struct ExternItemList {
2537 pub(crate) syntax: SyntaxNode, 2663 pub(crate) syntax: SyntaxNode,
@@ -2549,10 +2675,11 @@ impl AstNode for ExternItemList {
2549} 2675}
2550impl ast::ModuleItemOwner for ExternItemList {} 2676impl ast::ModuleItemOwner for ExternItemList {}
2551impl ExternItemList { 2677impl ExternItemList {
2552 pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) } 2678 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
2553 pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) } 2679 pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) }
2554 pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) } 2680 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
2555} 2681}
2682
2556#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2683#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2557pub struct ExternBlock { 2684pub struct ExternBlock {
2558 pub(crate) syntax: SyntaxNode, 2685 pub(crate) syntax: SyntaxNode,
@@ -2572,6 +2699,7 @@ impl ExternBlock {
2572 pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) } 2699 pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
2573 pub fn extern_item_list(&self) -> Option<ExternItemList> { support::child(&self.syntax) } 2700 pub fn extern_item_list(&self) -> Option<ExternItemList> { support::child(&self.syntax) }
2574} 2701}
2702
2575#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2703#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2576pub struct MetaItem { 2704pub struct MetaItem {
2577 pub(crate) syntax: SyntaxNode, 2705 pub(crate) syntax: SyntaxNode,
@@ -2589,10 +2717,11 @@ impl AstNode for MetaItem {
2589} 2717}
2590impl MetaItem { 2718impl MetaItem {
2591 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 2719 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
2592 pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) } 2720 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
2593 pub fn attr_input(&self) -> Option<AttrInput> { support::child(&self.syntax) } 2721 pub fn attr_input(&self) -> Option<AttrInput> { support::child(&self.syntax) }
2594 pub fn nested_meta_items(&self) -> AstChildren<MetaItem> { support::children(&self.syntax) } 2722 pub fn nested_meta_items(&self) -> AstChildren<MetaItem> { support::children(&self.syntax) }
2595} 2723}
2724
2596#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2725#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2597pub struct MacroDef { 2726pub struct MacroDef {
2598 pub(crate) syntax: SyntaxNode, 2727 pub(crate) syntax: SyntaxNode,
@@ -2612,6 +2741,7 @@ impl MacroDef {
2612 pub fn name(&self) -> Option<Name> { support::child(&self.syntax) } 2741 pub fn name(&self) -> Option<Name> { support::child(&self.syntax) }
2613 pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) } 2742 pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
2614} 2743}
2744
2615#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2745#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2616pub enum NominalDef { 2746pub enum NominalDef {
2617 StructDef(StructDef), 2747 StructDef(StructDef),
@@ -2654,6 +2784,7 @@ impl AstNode for NominalDef {
2654impl ast::NameOwner for NominalDef {} 2784impl ast::NameOwner for NominalDef {}
2655impl ast::TypeParamsOwner for NominalDef {} 2785impl ast::TypeParamsOwner for NominalDef {}
2656impl ast::AttrsOwner for NominalDef {} 2786impl ast::AttrsOwner for NominalDef {}
2787
2657#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2788#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2658pub enum GenericParam { 2789pub enum GenericParam {
2659 LifetimeParam(LifetimeParam), 2790 LifetimeParam(LifetimeParam),
@@ -2693,6 +2824,7 @@ impl AstNode for GenericParam {
2693 } 2824 }
2694 } 2825 }
2695} 2826}
2827
2696#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2828#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2697pub enum GenericArg { 2829pub enum GenericArg {
2698 LifetimeArg(LifetimeArg), 2830 LifetimeArg(LifetimeArg),
@@ -2738,6 +2870,7 @@ impl AstNode for GenericArg {
2738 } 2870 }
2739 } 2871 }
2740} 2872}
2873
2741#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2874#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2742pub enum TypeRef { 2875pub enum TypeRef {
2743 ParenType(ParenType), 2876 ParenType(ParenType),
@@ -2839,6 +2972,7 @@ impl AstNode for TypeRef {
2839 } 2972 }
2840 } 2973 }
2841} 2974}
2975
2842#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2976#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2843pub enum ModuleItem { 2977pub enum ModuleItem {
2844 StructDef(StructDef), 2978 StructDef(StructDef),
@@ -2949,6 +3083,7 @@ impl AstNode for ModuleItem {
2949impl ast::NameOwner for ModuleItem {} 3083impl ast::NameOwner for ModuleItem {}
2950impl ast::AttrsOwner for ModuleItem {} 3084impl ast::AttrsOwner for ModuleItem {}
2951impl ast::VisibilityOwner for ModuleItem {} 3085impl ast::VisibilityOwner for ModuleItem {}
3086
2952#[derive(Debug, Clone, PartialEq, Eq, Hash)] 3087#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2953pub enum ImplItem { 3088pub enum ImplItem {
2954 FnDef(FnDef), 3089 FnDef(FnDef),
@@ -2990,6 +3125,7 @@ impl AstNode for ImplItem {
2990} 3125}
2991impl ast::NameOwner for ImplItem {} 3126impl ast::NameOwner for ImplItem {}
2992impl ast::AttrsOwner for ImplItem {} 3127impl ast::AttrsOwner for ImplItem {}
3128
2993#[derive(Debug, Clone, PartialEq, Eq, Hash)] 3129#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2994pub enum ExternItem { 3130pub enum ExternItem {
2995 FnDef(FnDef), 3131 FnDef(FnDef),
@@ -3026,6 +3162,7 @@ impl AstNode for ExternItem {
3026impl ast::NameOwner for ExternItem {} 3162impl ast::NameOwner for ExternItem {}
3027impl ast::AttrsOwner for ExternItem {} 3163impl ast::AttrsOwner for ExternItem {}
3028impl ast::VisibilityOwner for ExternItem {} 3164impl ast::VisibilityOwner for ExternItem {}
3165
3029#[derive(Debug, Clone, PartialEq, Eq, Hash)] 3166#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3030pub enum Expr { 3167pub enum Expr {
3031 TupleExpr(TupleExpr), 3168 TupleExpr(TupleExpr),
@@ -3239,6 +3376,7 @@ impl AstNode for Expr {
3239 } 3376 }
3240} 3377}
3241impl ast::AttrsOwner for Expr {} 3378impl ast::AttrsOwner for Expr {}
3379
3242#[derive(Debug, Clone, PartialEq, Eq, Hash)] 3380#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3243pub enum Pat { 3381pub enum Pat {
3244 OrPat(OrPat), 3382 OrPat(OrPat),
@@ -3352,6 +3490,7 @@ impl AstNode for Pat {
3352 } 3490 }
3353 } 3491 }
3354} 3492}
3493
3355#[derive(Debug, Clone, PartialEq, Eq, Hash)] 3494#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3356pub enum RecordInnerPat { 3495pub enum RecordInnerPat {
3357 RecordFieldPat(RecordFieldPat), 3496 RecordFieldPat(RecordFieldPat),
@@ -3385,6 +3524,7 @@ impl AstNode for RecordInnerPat {
3385 } 3524 }
3386 } 3525 }
3387} 3526}
3527
3388#[derive(Debug, Clone, PartialEq, Eq, Hash)] 3528#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3389pub enum AttrInput { 3529pub enum AttrInput {
3390 Literal(Literal), 3530 Literal(Literal),
@@ -3418,6 +3558,7 @@ impl AstNode for AttrInput {
3418 } 3558 }
3419 } 3559 }
3420} 3560}
3561
3421#[derive(Debug, Clone, PartialEq, Eq, Hash)] 3562#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3422pub enum Stmt { 3563pub enum Stmt {
3423 LetStmt(LetStmt), 3564 LetStmt(LetStmt),
@@ -3451,6 +3592,7 @@ impl AstNode for Stmt {
3451 } 3592 }
3452 } 3593 }
3453} 3594}
3595
3454#[derive(Debug, Clone, PartialEq, Eq, Hash)] 3596#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3455pub enum FieldDefList { 3597pub enum FieldDefList {
3456 RecordFieldDefList(RecordFieldDefList), 3598 RecordFieldDefList(RecordFieldDefList),
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-16 16:12:16 +0100