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