aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--crates/ra_assists/src/handlers/add_impl.rs2
-rw-r--r--crates/ra_assists/src/handlers/add_new.rs3
-rw-r--r--crates/ra_parser/src/syntax_kind/generated.rs6
-rw-r--r--crates/ra_syntax/src/ast/extensions.rs12
-rw-r--r--crates/ra_syntax/src/ast/generated/nodes.rs124
-rw-r--r--crates/ra_syntax/src/ast/generated/tokens.rs239
-rw-r--r--xtask/src/ast_src.rs114
-rw-r--r--xtask/src/codegen.rs1
-rw-r--r--xtask/src/codegen/gen_syntax.rs182
9 files changed, 136 insertions, 547 deletions
diff --git a/crates/ra_assists/src/handlers/add_impl.rs b/crates/ra_assists/src/handlers/add_impl.rs
index 26dfed237..6622eadb2 100644
--- a/crates/ra_assists/src/handlers/add_impl.rs
+++ b/crates/ra_assists/src/handlers/add_impl.rs
@@ -1,5 +1,5 @@
1use ra_syntax::{ 1use ra_syntax::{
2 ast::{self, AstNode, AstToken, NameOwner, TypeParamsOwner}, 2 ast::{self, AstNode, NameOwner, TypeParamsOwner},
3 TextUnit, 3 TextUnit,
4}; 4};
5use stdx::{format_to, SepBy}; 5use stdx::{format_to, SepBy};
diff --git a/crates/ra_assists/src/handlers/add_new.rs b/crates/ra_assists/src/handlers/add_new.rs
index 30360af94..240b19fa3 100644
--- a/crates/ra_assists/src/handlers/add_new.rs
+++ b/crates/ra_assists/src/handlers/add_new.rs
@@ -1,8 +1,7 @@
1use hir::Adt; 1use hir::Adt;
2use ra_syntax::{ 2use ra_syntax::{
3 ast::{ 3 ast::{
4 self, AstNode, AstToken, NameOwner, StructKind, TypeAscriptionOwner, TypeParamsOwner, 4 self, AstNode, NameOwner, StructKind, TypeAscriptionOwner, TypeParamsOwner, VisibilityOwner,
5 VisibilityOwner,
6 }, 5 },
7 TextUnit, T, 6 TextUnit, T,
8}; 7};
diff --git a/crates/ra_parser/src/syntax_kind/generated.rs b/crates/ra_parser/src/syntax_kind/generated.rs
index 004f4e564..1dd4ce34a 100644
--- a/crates/ra_parser/src/syntax_kind/generated.rs
+++ b/crates/ra_parser/src/syntax_kind/generated.rs
@@ -655,4 +655,10 @@ macro_rules! T {
655 ( raw ) => { 655 ( raw ) => {
656 $crate::SyntaxKind::RAW_KW 656 $crate::SyntaxKind::RAW_KW
657 }; 657 };
658 ( lifetime ) => {
659 $crate::SyntaxKind::LIFETIME
660 };
661 ( ident ) => {
662 $crate::SyntaxKind::IDENT
663 };
658} 664}
diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs
index eee98ebc2..03d94170d 100644
--- a/crates/ra_syntax/src/ast/extensions.rs
+++ b/crates/ra_syntax/src/ast/extensions.rs
@@ -21,11 +21,7 @@ impl ast::NameRef {
21 } 21 }
22 22
23 pub fn as_tuple_field(&self) -> Option<usize> { 23 pub fn as_tuple_field(&self) -> Option<usize> {
24 if let Some(ast::NameRefToken::IntNumber(token)) = self.name_ref_token_token() { 24 self.text().parse().ok()
25 token.text().as_str().parse().ok()
26 } else {
27 None
28 }
29 } 25 }
30} 26}
31 27
@@ -315,7 +311,7 @@ pub enum TypeBoundKind {
315 /// for<'a> ... 311 /// for<'a> ...
316 ForType(ast::ForType), 312 ForType(ast::ForType),
317 /// 'a 313 /// 'a
318 Lifetime(ast::Lifetime), 314 Lifetime(SyntaxToken),
319} 315}
320 316
321impl ast::TypeBound { 317impl ast::TypeBound {
@@ -401,7 +397,7 @@ impl ast::RangePat {
401 pub fn start(&self) -> Option<ast::Pat> { 397 pub fn start(&self) -> Option<ast::Pat> {
402 self.syntax() 398 self.syntax()
403 .children_with_tokens() 399 .children_with_tokens()
404 .take_while(|it| !ast::RangeSeparator::can_cast(it.kind())) 400 .take_while(|it| !(it.kind() == T![..] || it.kind() == T![..=]))
405 .filter_map(|it| it.into_node()) 401 .filter_map(|it| it.into_node())
406 .find_map(ast::Pat::cast) 402 .find_map(ast::Pat::cast)
407 } 403 }
@@ -409,7 +405,7 @@ impl ast::RangePat {
409 pub fn end(&self) -> Option<ast::Pat> { 405 pub fn end(&self) -> Option<ast::Pat> {
410 self.syntax() 406 self.syntax()
411 .children_with_tokens() 407 .children_with_tokens()
412 .skip_while(|it| !ast::RangeSeparator::can_cast(it.kind())) 408 .skip_while(|it| !(it.kind() == T![..] || it.kind() == T![..=]))
413 .filter_map(|it| it.into_node()) 409 .filter_map(|it| it.into_node())
414 .find_map(ast::Pat::cast) 410 .find_map(ast::Pat::cast)
415 } 411 }
diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs
index 106a91c12..d67d733b1 100644
--- a/crates/ra_syntax/src/ast/generated/nodes.rs
+++ b/crates/ra_syntax/src/ast/generated/nodes.rs
@@ -1,6 +1,5 @@
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, *},
@@ -463,7 +462,7 @@ impl ImplDef {
463 pub fn const_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![const]) } 462 pub fn const_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![const]) }
464 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![unsafe]) } 463 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![unsafe]) }
465 pub fn impl_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![impl]) } 464 pub fn impl_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![impl]) }
466 pub fn excl_token(&self) -> Option<Excl> { support::token(&self.syntax) } 465 pub fn excl_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![!]) }
467 pub fn for_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![for]) } 466 pub fn for_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![for]) }
468 pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) } 467 pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
469} 468}
@@ -523,7 +522,7 @@ impl AstNode for NeverType {
523 fn syntax(&self) -> &SyntaxNode { &self.syntax } 522 fn syntax(&self) -> &SyntaxNode { &self.syntax }
524} 523}
525impl NeverType { 524impl NeverType {
526 pub fn excl_token(&self) -> Option<Excl> { support::token(&self.syntax) } 525 pub fn excl_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![!]) }
527} 526}
528#[derive(Debug, Clone, PartialEq, Eq, Hash)] 527#[derive(Debug, Clone, PartialEq, Eq, Hash)]
529pub struct PathType { 528pub struct PathType {
@@ -559,7 +558,7 @@ impl AstNode for PointerType {
559 fn syntax(&self) -> &SyntaxNode { &self.syntax } 558 fn syntax(&self) -> &SyntaxNode { &self.syntax }
560} 559}
561impl PointerType { 560impl PointerType {
562 pub fn star_token(&self) -> Option<Star> { support::token(&self.syntax) } 561 pub fn star_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![*]) }
563 pub fn const_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![const]) } 562 pub fn const_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![const]) }
564 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![mut]) } 563 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![mut]) }
565 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 564 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
@@ -622,8 +621,10 @@ impl AstNode for ReferenceType {
622 fn syntax(&self) -> &SyntaxNode { &self.syntax } 621 fn syntax(&self) -> &SyntaxNode { &self.syntax }
623} 622}
624impl ReferenceType { 623impl ReferenceType {
625 pub fn amp_token(&self) -> Option<Amp> { support::token(&self.syntax) } 624 pub fn amp_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![&]) }
626 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) } 625 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
626 support::token2(&self.syntax, T![lifetime])
627 }
627 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![mut]) } 628 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![mut]) }
628 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 629 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
629} 630}
@@ -643,7 +644,7 @@ impl AstNode for PlaceholderType {
643 fn syntax(&self) -> &SyntaxNode { &self.syntax } 644 fn syntax(&self) -> &SyntaxNode { &self.syntax }
644} 645}
645impl PlaceholderType { 646impl PlaceholderType {
646 pub fn underscore_token(&self) -> Option<Underscore> { support::token(&self.syntax) } 647 pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![_]) }
647} 648}
648#[derive(Debug, Clone, PartialEq, Eq, Hash)] 649#[derive(Debug, Clone, PartialEq, Eq, Hash)]
649pub struct FnPointerType { 650pub struct FnPointerType {
@@ -955,7 +956,9 @@ impl ContinueExpr {
955 pub fn continue_token(&self) -> Option<SyntaxToken> { 956 pub fn continue_token(&self) -> Option<SyntaxToken> {
956 support::token2(&self.syntax, T![continue]) 957 support::token2(&self.syntax, T![continue])
957 } 958 }
958 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) } 959 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
960 support::token2(&self.syntax, T![lifetime])
961 }
959} 962}
960#[derive(Debug, Clone, PartialEq, Eq, Hash)] 963#[derive(Debug, Clone, PartialEq, Eq, Hash)]
961pub struct BreakExpr { 964pub struct BreakExpr {
@@ -975,7 +978,9 @@ impl AstNode for BreakExpr {
975impl ast::AttrsOwner for BreakExpr {} 978impl ast::AttrsOwner for BreakExpr {}
976impl BreakExpr { 979impl BreakExpr {
977 pub fn break_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![break]) } 980 pub fn break_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![break]) }
978 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) } 981 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
982 support::token2(&self.syntax, T![lifetime])
983 }
979 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 984 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
980} 985}
981#[derive(Debug, Clone, PartialEq, Eq, Hash)] 986#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -994,7 +999,9 @@ impl AstNode for Label {
994 fn syntax(&self) -> &SyntaxNode { &self.syntax } 999 fn syntax(&self) -> &SyntaxNode { &self.syntax }
995} 1000}
996impl Label { 1001impl Label {
997 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) } 1002 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
1003 support::token2(&self.syntax, T![lifetime])
1004 }
998} 1005}
999#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1006#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1000pub struct BlockExpr { 1007pub struct BlockExpr {
@@ -1074,7 +1081,7 @@ impl ast::AttrsOwner for MethodCallExpr {}
1074impl ast::ArgListOwner for MethodCallExpr {} 1081impl ast::ArgListOwner for MethodCallExpr {}
1075impl MethodCallExpr { 1082impl MethodCallExpr {
1076 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1083 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1077 pub fn dot_token(&self) -> Option<Dot> { support::token(&self.syntax) } 1084 pub fn dot_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![.]) }
1078 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } 1085 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
1079 pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) } 1086 pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) }
1080} 1087}
@@ -1116,7 +1123,7 @@ impl AstNode for FieldExpr {
1116impl ast::AttrsOwner for FieldExpr {} 1123impl ast::AttrsOwner for FieldExpr {}
1117impl FieldExpr { 1124impl FieldExpr {
1118 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1125 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1119 pub fn dot_token(&self) -> Option<Dot> { support::token(&self.syntax) } 1126 pub fn dot_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![.]) }
1120 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } 1127 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
1121} 1128}
1122#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1129#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1137,7 +1144,7 @@ impl AstNode for AwaitExpr {
1137impl ast::AttrsOwner for AwaitExpr {} 1144impl ast::AttrsOwner for AwaitExpr {}
1138impl AwaitExpr { 1145impl AwaitExpr {
1139 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1146 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1140 pub fn dot_token(&self) -> Option<Dot> { support::token(&self.syntax) } 1147 pub fn dot_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![.]) }
1141 pub fn await_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![await]) } 1148 pub fn await_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![await]) }
1142} 1149}
1143#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1150#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1198,7 +1205,7 @@ impl AstNode for RefExpr {
1198} 1205}
1199impl ast::AttrsOwner for RefExpr {} 1206impl ast::AttrsOwner for RefExpr {}
1200impl RefExpr { 1207impl RefExpr {
1201 pub fn amp_token(&self) -> Option<Amp> { support::token(&self.syntax) } 1208 pub fn amp_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![&]) }
1202 pub fn raw_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![raw]) } 1209 pub fn raw_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![raw]) }
1203 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![mut]) } 1210 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![mut]) }
1204 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1211 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
@@ -1220,7 +1227,6 @@ impl AstNode for PrefixExpr {
1220} 1227}
1221impl ast::AttrsOwner for PrefixExpr {} 1228impl ast::AttrsOwner for PrefixExpr {}
1222impl PrefixExpr { 1229impl PrefixExpr {
1223 pub fn prefix_op_token(&self) -> Option<PrefixOp> { support::token(&self.syntax) }
1224 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1230 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1225} 1231}
1226#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1232#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1259,9 +1265,7 @@ impl AstNode for RangeExpr {
1259 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1265 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1260} 1266}
1261impl ast::AttrsOwner for RangeExpr {} 1267impl ast::AttrsOwner for RangeExpr {}
1262impl RangeExpr { 1268impl RangeExpr {}
1263 pub fn range_op_token(&self) -> Option<RangeOp> { support::token(&self.syntax) }
1264}
1265#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1269#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1266pub struct BinExpr { 1270pub struct BinExpr {
1267 pub(crate) syntax: SyntaxNode, 1271 pub(crate) syntax: SyntaxNode,
@@ -1294,9 +1298,7 @@ impl AstNode for Literal {
1294 } 1298 }
1295 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1299 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1296} 1300}
1297impl Literal { 1301impl Literal {}
1298 pub fn literal_token_token(&self) -> Option<LiteralToken> { support::token(&self.syntax) }
1299}
1300#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1302#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1301pub struct MatchExpr { 1303pub struct MatchExpr {
1302 pub(crate) syntax: SyntaxNode, 1304 pub(crate) syntax: SyntaxNode,
@@ -1358,7 +1360,7 @@ impl ast::AttrsOwner for MatchArm {}
1358impl MatchArm { 1360impl MatchArm {
1359 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 1361 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1360 pub fn guard(&self) -> Option<MatchGuard> { support::child(&self.syntax) } 1362 pub fn guard(&self) -> Option<MatchGuard> { support::child(&self.syntax) }
1361 pub fn fat_arrow_token(&self) -> Option<FatArrow> { support::token(&self.syntax) } 1363 pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![=>]) }
1362 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1364 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1363} 1365}
1364#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1366#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1417,7 +1419,7 @@ impl AstNode for RecordFieldList {
1417impl RecordFieldList { 1419impl RecordFieldList {
1418 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T!['{']) } 1420 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T!['{']) }
1419 pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) } 1421 pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) }
1420 pub fn dotdot_token(&self) -> Option<Dotdot> { support::token(&self.syntax) } 1422 pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![..]) }
1421 pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) } 1423 pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) }
1422 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T!['}']) } 1424 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T!['}']) }
1423} 1425}
@@ -1439,7 +1441,7 @@ impl AstNode for RecordField {
1439impl ast::AttrsOwner for RecordField {} 1441impl ast::AttrsOwner for RecordField {}
1440impl RecordField { 1442impl RecordField {
1441 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } 1443 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
1442 pub fn colon_token(&self) -> Option<Colon> { support::token(&self.syntax) } 1444 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![:]) }
1443 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1445 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1444} 1446}
1445#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1447#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1496,7 +1498,7 @@ impl AstNode for RefPat {
1496 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1498 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1497} 1499}
1498impl RefPat { 1500impl RefPat {
1499 pub fn amp_token(&self) -> Option<Amp> { support::token(&self.syntax) } 1501 pub fn amp_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![&]) }
1500 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![mut]) } 1502 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![mut]) }
1501 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 1503 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1502} 1504}
@@ -1539,7 +1541,7 @@ impl ast::NameOwner for BindPat {}
1539impl BindPat { 1541impl BindPat {
1540 pub fn ref_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![ref]) } 1542 pub fn ref_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![ref]) }
1541 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![mut]) } 1543 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![mut]) }
1542 pub fn at_token(&self) -> Option<At> { support::token(&self.syntax) } 1544 pub fn at_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![@]) }
1543 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 1545 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1544} 1546}
1545#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1547#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1558,7 +1560,7 @@ impl AstNode for PlaceholderPat {
1558 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1560 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1559} 1561}
1560impl PlaceholderPat { 1562impl PlaceholderPat {
1561 pub fn underscore_token(&self) -> Option<Underscore> { support::token(&self.syntax) } 1563 pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![_]) }
1562} 1564}
1563#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1565#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1564pub struct DotDotPat { 1566pub struct DotDotPat {
@@ -1576,7 +1578,7 @@ impl AstNode for DotDotPat {
1576 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1578 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1577} 1579}
1578impl DotDotPat { 1580impl DotDotPat {
1579 pub fn dotdot_token(&self) -> Option<Dotdot> { support::token(&self.syntax) } 1581 pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![..]) }
1580} 1582}
1581#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1583#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1582pub struct PathPat { 1584pub struct PathPat {
@@ -1631,9 +1633,7 @@ impl AstNode for RangePat {
1631 } 1633 }
1632 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1634 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1633} 1635}
1634impl RangePat { 1636impl RangePat {}
1635 pub fn range_separator_token(&self) -> Option<RangeSeparator> { support::token(&self.syntax) }
1636}
1637#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1637#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1638pub struct LiteralPat { 1638pub struct LiteralPat {
1639 pub(crate) syntax: SyntaxNode, 1639 pub(crate) syntax: SyntaxNode,
@@ -1713,7 +1713,7 @@ impl RecordFieldPatList {
1713 support::children(&self.syntax) 1713 support::children(&self.syntax)
1714 } 1714 }
1715 pub fn bind_pats(&self) -> AstChildren<BindPat> { support::children(&self.syntax) } 1715 pub fn bind_pats(&self) -> AstChildren<BindPat> { support::children(&self.syntax) }
1716 pub fn dotdot_token(&self) -> Option<Dotdot> { support::token(&self.syntax) } 1716 pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![..]) }
1717 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T!['}']) } 1717 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T!['}']) }
1718} 1718}
1719#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1719#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1734,7 +1734,7 @@ impl AstNode for RecordFieldPat {
1734impl ast::AttrsOwner for RecordFieldPat {} 1734impl ast::AttrsOwner for RecordFieldPat {}
1735impl ast::NameOwner for RecordFieldPat {} 1735impl ast::NameOwner for RecordFieldPat {}
1736impl RecordFieldPat { 1736impl RecordFieldPat {
1737 pub fn colon_token(&self) -> Option<Colon> { support::token(&self.syntax) } 1737 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![:]) }
1738 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 1738 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1739} 1739}
1740#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1740#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1815,7 +1815,7 @@ impl AstNode for Name {
1815 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1815 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1816} 1816}
1817impl Name { 1817impl Name {
1818 pub fn ident_token(&self) -> Option<Ident> { support::token(&self.syntax) } 1818 pub fn ident_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![ident]) }
1819} 1819}
1820#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1820#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1821pub struct NameRef { 1821pub struct NameRef {
@@ -1832,9 +1832,7 @@ impl AstNode for NameRef {
1832 } 1832 }
1833 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1833 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1834} 1834}
1835impl NameRef { 1835impl NameRef {}
1836 pub fn name_ref_token_token(&self) -> Option<NameRefToken> { support::token(&self.syntax) }
1837}
1838#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1836#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1839pub struct MacroCall { 1837pub struct MacroCall {
1840 pub(crate) syntax: SyntaxNode, 1838 pub(crate) syntax: SyntaxNode,
@@ -1855,7 +1853,7 @@ impl ast::AttrsOwner for MacroCall {}
1855impl ast::DocCommentsOwner for MacroCall {} 1853impl ast::DocCommentsOwner for MacroCall {}
1856impl MacroCall { 1854impl MacroCall {
1857 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 1855 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1858 pub fn excl_token(&self) -> Option<Excl> { support::token(&self.syntax) } 1856 pub fn excl_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![!]) }
1859 pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) } 1857 pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
1860 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![;]) } 1858 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![;]) }
1861} 1859}
@@ -1875,8 +1873,8 @@ impl AstNode for Attr {
1875 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1873 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1876} 1874}
1877impl Attr { 1875impl Attr {
1878 pub fn pound_token(&self) -> Option<Pound> { support::token(&self.syntax) } 1876 pub fn pound_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![#]) }
1879 pub fn excl_token(&self) -> Option<Excl> { support::token(&self.syntax) } 1877 pub fn excl_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![!]) }
1880 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T!['[']) } 1878 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T!['[']) }
1881 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 1879 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
1882 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![=]) } 1880 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![=]) }
@@ -1915,12 +1913,12 @@ impl AstNode for TypeParamList {
1915 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1913 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1916} 1914}
1917impl TypeParamList { 1915impl TypeParamList {
1918 pub fn l_angle_token(&self) -> Option<LAngle> { support::token(&self.syntax) } 1916 pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![<]) }
1919 pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) } 1917 pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) }
1920 pub fn type_params(&self) -> AstChildren<TypeParam> { support::children(&self.syntax) } 1918 pub fn type_params(&self) -> AstChildren<TypeParam> { support::children(&self.syntax) }
1921 pub fn lifetime_params(&self) -> AstChildren<LifetimeParam> { support::children(&self.syntax) } 1919 pub fn lifetime_params(&self) -> AstChildren<LifetimeParam> { support::children(&self.syntax) }
1922 pub fn const_params(&self) -> AstChildren<ConstParam> { support::children(&self.syntax) } 1920 pub fn const_params(&self) -> AstChildren<ConstParam> { support::children(&self.syntax) }
1923 pub fn r_angle_token(&self) -> Option<RAngle> { support::token(&self.syntax) } 1921 pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![>]) }
1924} 1922}
1925#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1923#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1926pub struct TypeParam { 1924pub struct TypeParam {
@@ -1983,7 +1981,9 @@ impl AstNode for LifetimeParam {
1983} 1981}
1984impl ast::AttrsOwner for LifetimeParam {} 1982impl ast::AttrsOwner for LifetimeParam {}
1985impl LifetimeParam { 1983impl LifetimeParam {
1986 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) } 1984 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
1985 support::token2(&self.syntax, T![lifetime])
1986 }
1987} 1987}
1988#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1988#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1989pub struct TypeBound { 1989pub struct TypeBound {
@@ -2001,7 +2001,9 @@ impl AstNode for TypeBound {
2001 fn syntax(&self) -> &SyntaxNode { &self.syntax } 2001 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2002} 2002}
2003impl TypeBound { 2003impl TypeBound {
2004 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) } 2004 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
2005 support::token2(&self.syntax, T![lifetime])
2006 }
2005 pub fn const_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![const]) } 2007 pub fn const_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![const]) }
2006 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 2008 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
2007} 2009}
@@ -2040,7 +2042,9 @@ impl AstNode for WherePred {
2040} 2042}
2041impl ast::TypeBoundsOwner for WherePred {} 2043impl ast::TypeBoundsOwner for WherePred {}
2042impl WherePred { 2044impl WherePred {
2043 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) } 2045 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
2046 support::token2(&self.syntax, T![lifetime])
2047 }
2044 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 2048 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
2045} 2049}
2046#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2050#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -2077,9 +2081,7 @@ impl AstNode for Abi {
2077 } 2081 }
2078 fn syntax(&self) -> &SyntaxNode { &self.syntax } 2082 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2079} 2083}
2080impl Abi { 2084impl Abi {}
2081 pub fn string_token(&self) -> Option<String> { support::token(&self.syntax) }
2082}
2083#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2085#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2084pub struct ExprStmt { 2086pub struct ExprStmt {
2085 pub(crate) syntax: SyntaxNode, 2087 pub(crate) syntax: SyntaxNode,
@@ -2207,8 +2209,10 @@ impl AstNode for SelfParam {
2207impl ast::TypeAscriptionOwner for SelfParam {} 2209impl ast::TypeAscriptionOwner for SelfParam {}
2208impl ast::AttrsOwner for SelfParam {} 2210impl ast::AttrsOwner for SelfParam {}
2209impl SelfParam { 2211impl SelfParam {
2210 pub fn amp_token(&self) -> Option<Amp> { support::token(&self.syntax) } 2212 pub fn amp_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![&]) }
2211 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) } 2213 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
2214 support::token2(&self.syntax, T![lifetime])
2215 }
2212 pub fn self_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![self]) } 2216 pub fn self_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![self]) }
2213} 2217}
2214#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2218#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -2230,7 +2234,7 @@ impl ast::TypeAscriptionOwner for Param {}
2230impl ast::AttrsOwner for Param {} 2234impl ast::AttrsOwner for Param {}
2231impl Param { 2235impl Param {
2232 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 2236 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
2233 pub fn dotdotdot_token(&self) -> Option<Dotdotdot> { support::token(&self.syntax) } 2237 pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![...]) }
2234} 2238}
2235#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2239#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2236pub struct UseItem { 2240pub struct UseItem {
@@ -2270,7 +2274,7 @@ impl AstNode for UseTree {
2270} 2274}
2271impl UseTree { 2275impl UseTree {
2272 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 2276 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
2273 pub fn star_token(&self) -> Option<Star> { support::token(&self.syntax) } 2277 pub fn star_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![*]) }
2274 pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) } 2278 pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) }
2275 pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) } 2279 pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) }
2276} 2280}
@@ -2391,14 +2395,14 @@ impl AstNode for PathSegment {
2391 fn syntax(&self) -> &SyntaxNode { &self.syntax } 2395 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2392} 2396}
2393impl PathSegment { 2397impl PathSegment {
2394 pub fn coloncolon_token(&self) -> Option<Coloncolon> { support::token(&self.syntax) } 2398 pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![::]) }
2395 pub fn l_angle_token(&self) -> Option<LAngle> { support::token(&self.syntax) } 2399 pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![<]) }
2396 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } 2400 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
2397 pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) } 2401 pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) }
2398 pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } 2402 pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
2399 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } 2403 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
2400 pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) } 2404 pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) }
2401 pub fn r_angle_token(&self) -> Option<RAngle> { support::token(&self.syntax) } 2405 pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![>]) }
2402} 2406}
2403#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2407#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2404pub struct TypeArgList { 2408pub struct TypeArgList {
@@ -2416,14 +2420,14 @@ impl AstNode for TypeArgList {
2416 fn syntax(&self) -> &SyntaxNode { &self.syntax } 2420 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2417} 2421}
2418impl TypeArgList { 2422impl TypeArgList {
2419 pub fn coloncolon_token(&self) -> Option<Coloncolon> { support::token(&self.syntax) } 2423 pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![::]) }
2420 pub fn l_angle_token(&self) -> Option<LAngle> { support::token(&self.syntax) } 2424 pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![<]) }
2421 pub fn generic_args(&self) -> AstChildren<GenericArg> { support::children(&self.syntax) } 2425 pub fn generic_args(&self) -> AstChildren<GenericArg> { support::children(&self.syntax) }
2422 pub fn type_args(&self) -> AstChildren<TypeArg> { support::children(&self.syntax) } 2426 pub fn type_args(&self) -> AstChildren<TypeArg> { support::children(&self.syntax) }
2423 pub fn lifetime_args(&self) -> AstChildren<LifetimeArg> { support::children(&self.syntax) } 2427 pub fn lifetime_args(&self) -> AstChildren<LifetimeArg> { support::children(&self.syntax) }
2424 pub fn assoc_type_args(&self) -> AstChildren<AssocTypeArg> { support::children(&self.syntax) } 2428 pub fn assoc_type_args(&self) -> AstChildren<AssocTypeArg> { support::children(&self.syntax) }
2425 pub fn const_args(&self) -> AstChildren<ConstArg> { support::children(&self.syntax) } 2429 pub fn const_args(&self) -> AstChildren<ConstArg> { support::children(&self.syntax) }
2426 pub fn r_angle_token(&self) -> Option<RAngle> { support::token(&self.syntax) } 2430 pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![>]) }
2427} 2431}
2428#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2432#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2429pub struct TypeArg { 2433pub struct TypeArg {
@@ -2480,7 +2484,9 @@ impl AstNode for LifetimeArg {
2480 fn syntax(&self) -> &SyntaxNode { &self.syntax } 2484 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2481} 2485}
2482impl LifetimeArg { 2486impl LifetimeArg {
2483 pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) } 2487 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
2488 support::token2(&self.syntax, T![lifetime])
2489 }
2484} 2490}
2485#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2491#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2486pub struct ConstArg { 2492pub struct ConstArg {
diff --git a/crates/ra_syntax/src/ast/generated/tokens.rs b/crates/ra_syntax/src/ast/generated/tokens.rs
index 7611ce4cb..293f91c2e 100644
--- a/crates/ra_syntax/src/ast/generated/tokens.rs
+++ b/crates/ra_syntax/src/ast/generated/tokens.rs
@@ -1365,242 +1365,3 @@ impl AstToken for RDollar {
1365 } 1365 }
1366 fn syntax(&self) -> &SyntaxToken { &self.syntax } 1366 fn syntax(&self) -> &SyntaxToken { &self.syntax }
1367} 1367}
1368#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1369pub enum RangeSeparator {
1370 Dotdot(Dotdot),
1371 Dotdotdot(Dotdotdot),
1372 Dotdoteq(Dotdoteq),
1373}
1374impl From<Dotdot> for RangeSeparator {
1375 fn from(node: Dotdot) -> RangeSeparator { RangeSeparator::Dotdot(node) }
1376}
1377impl From<Dotdotdot> for RangeSeparator {
1378 fn from(node: Dotdotdot) -> RangeSeparator { RangeSeparator::Dotdotdot(node) }
1379}
1380impl From<Dotdoteq> for RangeSeparator {
1381 fn from(node: Dotdoteq) -> RangeSeparator { RangeSeparator::Dotdoteq(node) }
1382}
1383impl std::fmt::Display for RangeSeparator {
1384 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1385 std::fmt::Display::fmt(self.syntax(), f)
1386 }
1387}
1388impl AstToken for RangeSeparator {
1389 fn can_cast(kind: SyntaxKind) -> bool {
1390 match kind {
1391 DOTDOT | DOTDOTDOT | DOTDOTEQ => true,
1392 _ => false,
1393 }
1394 }
1395 fn cast(syntax: SyntaxToken) -> Option<Self> {
1396 let res = match syntax.kind() {
1397 DOTDOT => RangeSeparator::Dotdot(Dotdot { syntax }),
1398 DOTDOTDOT => RangeSeparator::Dotdotdot(Dotdotdot { syntax }),
1399 DOTDOTEQ => RangeSeparator::Dotdoteq(Dotdoteq { syntax }),
1400 _ => return None,
1401 };
1402 Some(res)
1403 }
1404 fn syntax(&self) -> &SyntaxToken {
1405 match self {
1406 RangeSeparator::Dotdot(it) => &it.syntax,
1407 RangeSeparator::Dotdotdot(it) => &it.syntax,
1408 RangeSeparator::Dotdoteq(it) => &it.syntax,
1409 }
1410 }
1411}
1412#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1413pub enum PrefixOp {
1414 Minus(Minus),
1415 Excl(Excl),
1416 Star(Star),
1417}
1418impl From<Minus> for PrefixOp {
1419 fn from(node: Minus) -> PrefixOp { PrefixOp::Minus(node) }
1420}
1421impl From<Excl> for PrefixOp {
1422 fn from(node: Excl) -> PrefixOp { PrefixOp::Excl(node) }
1423}
1424impl From<Star> for PrefixOp {
1425 fn from(node: Star) -> PrefixOp { PrefixOp::Star(node) }
1426}
1427impl std::fmt::Display for PrefixOp {
1428 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1429 std::fmt::Display::fmt(self.syntax(), f)
1430 }
1431}
1432impl AstToken for PrefixOp {
1433 fn can_cast(kind: SyntaxKind) -> bool {
1434 match kind {
1435 MINUS | EXCL | STAR => true,
1436 _ => false,
1437 }
1438 }
1439 fn cast(syntax: SyntaxToken) -> Option<Self> {
1440 let res = match syntax.kind() {
1441 MINUS => PrefixOp::Minus(Minus { syntax }),
1442 EXCL => PrefixOp::Excl(Excl { syntax }),
1443 STAR => PrefixOp::Star(Star { syntax }),
1444 _ => return None,
1445 };
1446 Some(res)
1447 }
1448 fn syntax(&self) -> &SyntaxToken {
1449 match self {
1450 PrefixOp::Minus(it) => &it.syntax,
1451 PrefixOp::Excl(it) => &it.syntax,
1452 PrefixOp::Star(it) => &it.syntax,
1453 }
1454 }
1455}
1456#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1457pub enum RangeOp {
1458 Dotdot(Dotdot),
1459 Dotdoteq(Dotdoteq),
1460}
1461impl From<Dotdot> for RangeOp {
1462 fn from(node: Dotdot) -> RangeOp { RangeOp::Dotdot(node) }
1463}
1464impl From<Dotdoteq> for RangeOp {
1465 fn from(node: Dotdoteq) -> RangeOp { RangeOp::Dotdoteq(node) }
1466}
1467impl std::fmt::Display for RangeOp {
1468 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1469 std::fmt::Display::fmt(self.syntax(), f)
1470 }
1471}
1472impl AstToken for RangeOp {
1473 fn can_cast(kind: SyntaxKind) -> bool {
1474 match kind {
1475 DOTDOT | DOTDOTEQ => true,
1476 _ => false,
1477 }
1478 }
1479 fn cast(syntax: SyntaxToken) -> Option<Self> {
1480 let res = match syntax.kind() {
1481 DOTDOT => RangeOp::Dotdot(Dotdot { syntax }),
1482 DOTDOTEQ => RangeOp::Dotdoteq(Dotdoteq { syntax }),
1483 _ => return None,
1484 };
1485 Some(res)
1486 }
1487 fn syntax(&self) -> &SyntaxToken {
1488 match self {
1489 RangeOp::Dotdot(it) => &it.syntax,
1490 RangeOp::Dotdoteq(it) => &it.syntax,
1491 }
1492 }
1493}
1494#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1495pub enum LiteralToken {
1496 IntNumber(IntNumber),
1497 FloatNumber(FloatNumber),
1498 String(String),
1499 RawString(RawString),
1500 ByteString(ByteString),
1501 RawByteString(RawByteString),
1502 Char(Char),
1503 Byte(Byte),
1504}
1505impl From<IntNumber> for LiteralToken {
1506 fn from(node: IntNumber) -> LiteralToken { LiteralToken::IntNumber(node) }
1507}
1508impl From<FloatNumber> for LiteralToken {
1509 fn from(node: FloatNumber) -> LiteralToken { LiteralToken::FloatNumber(node) }
1510}
1511impl From<String> for LiteralToken {
1512 fn from(node: String) -> LiteralToken { LiteralToken::String(node) }
1513}
1514impl From<RawString> for LiteralToken {
1515 fn from(node: RawString) -> LiteralToken { LiteralToken::RawString(node) }
1516}
1517impl From<ByteString> for LiteralToken {
1518 fn from(node: ByteString) -> LiteralToken { LiteralToken::ByteString(node) }
1519}
1520impl From<RawByteString> for LiteralToken {
1521 fn from(node: RawByteString) -> LiteralToken { LiteralToken::RawByteString(node) }
1522}
1523impl From<Char> for LiteralToken {
1524 fn from(node: Char) -> LiteralToken { LiteralToken::Char(node) }
1525}
1526impl From<Byte> for LiteralToken {
1527 fn from(node: Byte) -> LiteralToken { LiteralToken::Byte(node) }
1528}
1529impl std::fmt::Display for LiteralToken {
1530 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1531 std::fmt::Display::fmt(self.syntax(), f)
1532 }
1533}
1534impl AstToken for LiteralToken {
1535 fn can_cast(kind: SyntaxKind) -> bool {
1536 match kind {
1537 INT_NUMBER | FLOAT_NUMBER | STRING | RAW_STRING | BYTE_STRING | RAW_BYTE_STRING
1538 | CHAR | BYTE => true,
1539 _ => false,
1540 }
1541 }
1542 fn cast(syntax: SyntaxToken) -> Option<Self> {
1543 let res = match syntax.kind() {
1544 INT_NUMBER => LiteralToken::IntNumber(IntNumber { syntax }),
1545 FLOAT_NUMBER => LiteralToken::FloatNumber(FloatNumber { syntax }),
1546 STRING => LiteralToken::String(String { syntax }),
1547 RAW_STRING => LiteralToken::RawString(RawString { syntax }),
1548 BYTE_STRING => LiteralToken::ByteString(ByteString { syntax }),
1549 RAW_BYTE_STRING => LiteralToken::RawByteString(RawByteString { syntax }),
1550 CHAR => LiteralToken::Char(Char { syntax }),
1551 BYTE => LiteralToken::Byte(Byte { syntax }),
1552 _ => return None,
1553 };
1554 Some(res)
1555 }
1556 fn syntax(&self) -> &SyntaxToken {
1557 match self {
1558 LiteralToken::IntNumber(it) => &it.syntax,
1559 LiteralToken::FloatNumber(it) => &it.syntax,
1560 LiteralToken::String(it) => &it.syntax,
1561 LiteralToken::RawString(it) => &it.syntax,
1562 LiteralToken::ByteString(it) => &it.syntax,
1563 LiteralToken::RawByteString(it) => &it.syntax,
1564 LiteralToken::Char(it) => &it.syntax,
1565 LiteralToken::Byte(it) => &it.syntax,
1566 }
1567 }
1568}
1569#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1570pub enum NameRefToken {
1571 Ident(Ident),
1572 IntNumber(IntNumber),
1573}
1574impl From<Ident> for NameRefToken {
1575 fn from(node: Ident) -> NameRefToken { NameRefToken::Ident(node) }
1576}
1577impl From<IntNumber> for NameRefToken {
1578 fn from(node: IntNumber) -> NameRefToken { NameRefToken::IntNumber(node) }
1579}
1580impl std::fmt::Display for NameRefToken {
1581 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1582 std::fmt::Display::fmt(self.syntax(), f)
1583 }
1584}
1585impl AstToken for NameRefToken {
1586 fn can_cast(kind: SyntaxKind) -> bool {
1587 match kind {
1588 IDENT | INT_NUMBER => true,
1589 _ => false,
1590 }
1591 }
1592 fn cast(syntax: SyntaxToken) -> Option<Self> {
1593 let res = match syntax.kind() {
1594 IDENT => NameRefToken::Ident(Ident { syntax }),
1595 INT_NUMBER => NameRefToken::IntNumber(IntNumber { syntax }),
1596 _ => return None,
1597 };
1598 Some(res)
1599 }
1600 fn syntax(&self) -> &SyntaxToken {
1601 match self {
1602 NameRefToken::Ident(it) => &it.syntax,
1603 NameRefToken::IntNumber(it) => &it.syntax,
1604 }
1605 }
1606}
diff --git a/xtask/src/ast_src.rs b/xtask/src/ast_src.rs
index f9cd12d0d..554afc76a 100644
--- a/xtask/src/ast_src.rs
+++ b/xtask/src/ast_src.rs
@@ -227,7 +227,6 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc {
227pub(crate) struct AstSrc<'a> { 227pub(crate) struct AstSrc<'a> {
228 pub(crate) nodes: &'a [AstNodeSrc<'a>], 228 pub(crate) nodes: &'a [AstNodeSrc<'a>],
229 pub(crate) enums: &'a [AstEnumSrc<'a>], 229 pub(crate) enums: &'a [AstEnumSrc<'a>],
230 pub(crate) token_enums: &'a [AstEnumSrc<'a>],
231} 230}
232 231
233pub(crate) struct AstNodeSrc<'a> { 232pub(crate) struct AstNodeSrc<'a> {
@@ -415,11 +414,11 @@ pub(crate) const AST_SRC: AstSrc = AstSrc {
415 struct TupleType { T!['('], fields: [TypeRef], T![')'] } 414 struct TupleType { T!['('], fields: [TypeRef], T![')'] }
416 struct NeverType { T![!] } 415 struct NeverType { T![!] }
417 struct PathType { Path } 416 struct PathType { Path }
418 struct PointerType { Star, T![const], T![mut], TypeRef } 417 struct PointerType { T![*], T![const], T![mut], TypeRef }
419 struct ArrayType { T!['['], TypeRef, T![;], Expr, T![']'] } 418 struct ArrayType { T!['['], TypeRef, T![;], Expr, T![']'] }
420 struct SliceType { T!['['], TypeRef, T![']'] } 419 struct SliceType { T!['['], TypeRef, T![']'] }
421 struct ReferenceType { Amp, Lifetime, T![mut], TypeRef } 420 struct ReferenceType { T![&], T![lifetime], T![mut], TypeRef }
422 struct PlaceholderType { Underscore } 421 struct PlaceholderType { T![_] }
423 struct FnPointerType { Abi, T![unsafe], T![fn], ParamList, RetType } 422 struct FnPointerType { Abi, T![unsafe], T![fn], ParamList, RetType }
424 struct ForType { T![for], TypeParamList, TypeRef } 423 struct ForType { T![for], TypeParamList, TypeRef }
425 struct ImplTraitType: TypeBoundsOwner { T![impl] } 424 struct ImplTraitType: TypeBoundsOwner { T![impl] }
@@ -447,33 +446,33 @@ pub(crate) const AST_SRC: AstSrc = AstSrc {
447 iterable: Expr, 446 iterable: Expr,
448 } 447 }
449 struct WhileExpr: AttrsOwner, LoopBodyOwner { T![while], Condition } 448 struct WhileExpr: AttrsOwner, LoopBodyOwner { T![while], Condition }
450 struct ContinueExpr: AttrsOwner { T![continue], Lifetime } 449 struct ContinueExpr: AttrsOwner { T![continue], T![lifetime] }
451 struct BreakExpr: AttrsOwner { T![break], Lifetime, Expr } 450 struct BreakExpr: AttrsOwner { T![break], T![lifetime], Expr }
452 struct Label { Lifetime } 451 struct Label { T![lifetime] }
453 struct BlockExpr: AttrsOwner { Label, T![unsafe], Block } 452 struct BlockExpr: AttrsOwner { Label, T![unsafe], Block }
454 struct ReturnExpr: AttrsOwner { Expr } 453 struct ReturnExpr: AttrsOwner { Expr }
455 struct CallExpr: ArgListOwner { Expr } 454 struct CallExpr: ArgListOwner { Expr }
456 struct MethodCallExpr: AttrsOwner, ArgListOwner { 455 struct MethodCallExpr: AttrsOwner, ArgListOwner {
457 Expr, Dot, NameRef, TypeArgList, 456 Expr, T![.], NameRef, TypeArgList,
458 } 457 }
459 struct IndexExpr: AttrsOwner { T!['['], T![']'] } 458 struct IndexExpr: AttrsOwner { T!['['], T![']'] }
460 struct FieldExpr: AttrsOwner { Expr, Dot, NameRef } 459 struct FieldExpr: AttrsOwner { Expr, T![.], NameRef }
461 struct AwaitExpr: AttrsOwner { Expr, Dot, T![await] } 460 struct AwaitExpr: AttrsOwner { Expr, T![.], T![await] }
462 struct TryExpr: AttrsOwner { T![try], Expr } 461 struct TryExpr: AttrsOwner { T![try], Expr }
463 struct CastExpr: AttrsOwner { Expr, T![as], TypeRef } 462 struct CastExpr: AttrsOwner { Expr, T![as], TypeRef }
464 struct RefExpr: AttrsOwner { Amp, T![raw], T![mut], Expr } 463 struct RefExpr: AttrsOwner { T![&], T![raw], T![mut], Expr }
465 struct PrefixExpr: AttrsOwner { PrefixOp, Expr } 464 struct PrefixExpr: AttrsOwner { /*PrefixOp,*/ Expr }
466 struct BoxExpr: AttrsOwner { T![box], Expr } 465 struct BoxExpr: AttrsOwner { T![box], Expr }
467 struct RangeExpr: AttrsOwner { RangeOp } 466 struct RangeExpr: AttrsOwner { /*RangeOp*/ }
468 struct BinExpr: AttrsOwner { /*BinOp*/ } 467 struct BinExpr: AttrsOwner { /*BinOp*/ }
469 struct Literal { LiteralToken } 468 struct Literal { /*LiteralToken*/ }
470 469
471 struct MatchExpr: AttrsOwner { T![match], Expr, MatchArmList } 470 struct MatchExpr: AttrsOwner { T![match], Expr, MatchArmList }
472 struct MatchArmList: AttrsOwner { T!['{'], arms: [MatchArm], T!['}'] } 471 struct MatchArmList: AttrsOwner { T!['{'], arms: [MatchArm], T!['}'] }
473 struct MatchArm: AttrsOwner { 472 struct MatchArm: AttrsOwner {
474 pat: Pat, 473 pat: Pat,
475 guard: MatchGuard, 474 guard: MatchGuard,
476 FatArrow, 475 T![=>],
477 Expr, 476 Expr,
478 } 477 }
479 struct MatchGuard { T![if], Expr } 478 struct MatchGuard { T![if], Expr }
@@ -482,22 +481,22 @@ pub(crate) const AST_SRC: AstSrc = AstSrc {
482 struct RecordFieldList { 481 struct RecordFieldList {
483 T!['{'], 482 T!['{'],
484 fields: [RecordField], 483 fields: [RecordField],
485 Dotdot, 484 T![..],
486 spread: Expr, 485 spread: Expr,
487 T!['}'] 486 T!['}']
488 } 487 }
489 struct RecordField: AttrsOwner { NameRef, Colon, Expr } 488 struct RecordField: AttrsOwner { NameRef, T![:], Expr }
490 489
491 struct OrPat { pats: [Pat] } 490 struct OrPat { pats: [Pat] }
492 struct ParenPat { T!['('], Pat, T![')'] } 491 struct ParenPat { T!['('], Pat, T![')'] }
493 struct RefPat { Amp, T![mut], Pat } 492 struct RefPat { T![&], T![mut], Pat }
494 struct BoxPat { T![box], Pat } 493 struct BoxPat { T![box], Pat }
495 struct BindPat: AttrsOwner, NameOwner { T![ref], T![mut], At, Pat } 494 struct BindPat: AttrsOwner, NameOwner { T![ref], T![mut], T![@], Pat }
496 struct PlaceholderPat { Underscore } 495 struct PlaceholderPat { T![_] }
497 struct DotDotPat { Dotdot } 496 struct DotDotPat { T![..] }
498 struct PathPat { Path } 497 struct PathPat { Path }
499 struct SlicePat { T!['['], args: [Pat], T![']'] } 498 struct SlicePat { T!['['], args: [Pat], T![']'] }
500 struct RangePat { RangeSeparator } 499 struct RangePat { /*RangeSeparator*/ }
501 struct LiteralPat { Literal } 500 struct LiteralPat { Literal }
502 struct MacroPat { MacroCall } 501 struct MacroPat { MacroCall }
503 502
@@ -507,30 +506,30 @@ pub(crate) const AST_SRC: AstSrc = AstSrc {
507 pats: [RecordInnerPat], 506 pats: [RecordInnerPat],
508 record_field_pats: [RecordFieldPat], 507 record_field_pats: [RecordFieldPat],
509 bind_pats: [BindPat], 508 bind_pats: [BindPat],
510 Dotdot, 509 T![..],
511 T!['}'] 510 T!['}']
512 } 511 }
513 struct RecordFieldPat: AttrsOwner, NameOwner { Colon, Pat } 512 struct RecordFieldPat: AttrsOwner, NameOwner { T![:], Pat }
514 513
515 struct TupleStructPat { Path, T!['('], args: [Pat], T![')'] } 514 struct TupleStructPat { Path, T!['('], args: [Pat], T![')'] }
516 struct TuplePat { T!['('], args: [Pat], T![')'] } 515 struct TuplePat { T!['('], args: [Pat], T![')'] }
517 516
518 struct Visibility { T![pub], T![super], T![self], T![crate] } 517 struct Visibility { T![pub], T![super], T![self], T![crate] }
519 struct Name { Ident } 518 struct Name { T![ident] }
520 struct NameRef { NameRefToken } 519 struct NameRef { /*NameRefToken*/ }
521 520
522 struct MacroCall: NameOwner, AttrsOwner,DocCommentsOwner { 521 struct MacroCall: NameOwner, AttrsOwner,DocCommentsOwner {
523 Path, T![!], TokenTree, T![;] 522 Path, T![!], TokenTree, T![;]
524 } 523 }
525 struct Attr { Pound, T![!], T!['['], Path, T![=], input: AttrInput, T![']'] } 524 struct Attr { T![#], T![!], T!['['], Path, T![=], input: AttrInput, T![']'] }
526 struct TokenTree {} 525 struct TokenTree {}
527 struct TypeParamList { 526 struct TypeParamList {
528 LAngle, 527 T![<],
529 generic_params: [GenericParam], 528 generic_params: [GenericParam],
530 type_params: [TypeParam], 529 type_params: [TypeParam],
531 lifetime_params: [LifetimeParam], 530 lifetime_params: [LifetimeParam],
532 const_params: [ConstParam], 531 const_params: [ConstParam],
533 RAngle 532 T![>]
534 } 533 }
535 struct TypeParam: NameOwner, AttrsOwner, TypeBoundsOwner { 534 struct TypeParam: NameOwner, AttrsOwner, TypeBoundsOwner {
536 T![=], 535 T![=],
@@ -540,12 +539,12 @@ pub(crate) const AST_SRC: AstSrc = AstSrc {
540 T![=], 539 T![=],
541 default_val: Expr, 540 default_val: Expr,
542 } 541 }
543 struct LifetimeParam: AttrsOwner { Lifetime} 542 struct LifetimeParam: AttrsOwner { T![lifetime] }
544 struct TypeBound { Lifetime, /* Question, */ T![const], /* Question, */ TypeRef} 543 struct TypeBound { T![lifetime], /* Question, */ T![const], /* Question, */ TypeRef}
545 struct TypeBoundList { bounds: [TypeBound] } 544 struct TypeBoundList { bounds: [TypeBound] }
546 struct WherePred: TypeBoundsOwner { Lifetime, TypeRef } 545 struct WherePred: TypeBoundsOwner { T![lifetime], TypeRef }
547 struct WhereClause { T![where], predicates: [WherePred] } 546 struct WhereClause { T![where], predicates: [WherePred] }
548 struct Abi { String } 547 struct Abi { /*String*/ }
549 struct ExprStmt: AttrsOwner { Expr, T![;] } 548 struct ExprStmt: AttrsOwner { Expr, T![;] }
550 struct LetStmt: AttrsOwner, TypeAscriptionOwner { 549 struct LetStmt: AttrsOwner, TypeAscriptionOwner {
551 T![let], 550 T![let],
@@ -567,17 +566,17 @@ pub(crate) const AST_SRC: AstSrc = AstSrc {
567 params: [Param], 566 params: [Param],
568 T![')'] 567 T![')']
569 } 568 }
570 struct SelfParam: TypeAscriptionOwner, AttrsOwner { Amp, Lifetime, T![self] } 569 struct SelfParam: TypeAscriptionOwner, AttrsOwner { T![&], T![lifetime], T![self] }
571 struct Param: TypeAscriptionOwner, AttrsOwner { 570 struct Param: TypeAscriptionOwner, AttrsOwner {
572 Pat, 571 Pat,
573 Dotdotdot 572 T![...]
574 } 573 }
575 struct UseItem: AttrsOwner, VisibilityOwner { 574 struct UseItem: AttrsOwner, VisibilityOwner {
576 T![use], 575 T![use],
577 UseTree, 576 UseTree,
578 } 577 }
579 struct UseTree { 578 struct UseTree {
580 Path, Star, UseTreeList, Alias 579 Path, T![*], UseTreeList, Alias
581 } 580 }
582 struct Alias: NameOwner { T![as] } 581 struct Alias: NameOwner { T![as] }
583 struct UseTreeList { T!['{'], use_trees: [UseTree], T!['}'] } 582 struct UseTreeList { T!['{'], use_trees: [UseTree], T!['}'] }
@@ -594,21 +593,21 @@ pub(crate) const AST_SRC: AstSrc = AstSrc {
594 qualifier: Path, 593 qualifier: Path,
595 } 594 }
596 struct PathSegment { 595 struct PathSegment {
597 Coloncolon, LAngle, NameRef, TypeArgList, ParamList, RetType, PathType, RAngle 596 T![::], T![<], NameRef, TypeArgList, ParamList, RetType, PathType, T![>]
598 } 597 }
599 struct TypeArgList { 598 struct TypeArgList {
600 Coloncolon, 599 T![::],
601 LAngle, 600 T![<],
602 generic_args: [GenericArg], 601 generic_args: [GenericArg],
603 type_args: [TypeArg], 602 type_args: [TypeArg],
604 lifetime_args: [LifetimeArg], 603 lifetime_args: [LifetimeArg],
605 assoc_type_args: [AssocTypeArg], 604 assoc_type_args: [AssocTypeArg],
606 const_args: [ConstArg], 605 const_args: [ConstArg],
607 RAngle 606 T![>]
608 } 607 }
609 struct TypeArg { TypeRef } 608 struct TypeArg { TypeRef }
610 struct AssocTypeArg : TypeBoundsOwner { NameRef, T![=], TypeRef } 609 struct AssocTypeArg : TypeBoundsOwner { NameRef, T![=], TypeRef }
611 struct LifetimeArg { Lifetime } 610 struct LifetimeArg { T![lifetime] }
612 struct ConstArg { Literal, T![=], BlockExpr } 611 struct ConstArg { Literal, T![=], BlockExpr }
613 612
614 struct MacroItems: ModuleItemOwner{ } 613 struct MacroItems: ModuleItemOwner{ }
@@ -767,37 +766,4 @@ pub(crate) const AST_SRC: AstSrc = AstSrc {
767 TupleFieldDefList, 766 TupleFieldDefList,
768 } 767 }
769 }, 768 },
770
771 token_enums: &ast_enums! {
772 enum RangeSeparator { Dotdot, Dotdotdot, Dotdoteq}
773
774 enum PrefixOp {
775 Minus,
776 T![!],
777 Star
778 }
779
780 enum RangeOp {
781 Dotdot,
782 Dotdoteq
783 }
784
785 enum LiteralToken {
786 IntNumber,
787 FloatNumber,
788 String,
789 RawString,
790 // TrueKw,
791 // FalseKw,
792 ByteString,
793 RawByteString,
794 Char,
795 Byte
796 }
797
798 enum NameRefToken {
799 Ident,
800 IntNumber
801 }
802 },
803}; 769};
diff --git a/xtask/src/codegen.rs b/xtask/src/codegen.rs
index 678b40133..e6ba2009c 100644
--- a/xtask/src/codegen.rs
+++ b/xtask/src/codegen.rs
@@ -24,7 +24,6 @@ const ERR_INLINE_TESTS_DIR: &str = "crates/ra_syntax/test_data/parser/inline/err
24 24
25const SYNTAX_KINDS: &str = "crates/ra_parser/src/syntax_kind/generated.rs"; 25const SYNTAX_KINDS: &str = "crates/ra_parser/src/syntax_kind/generated.rs";
26const AST_NODES: &str = "crates/ra_syntax/src/ast/generated/nodes.rs"; 26const AST_NODES: &str = "crates/ra_syntax/src/ast/generated/nodes.rs";
27const AST_TOKENS: &str = "crates/ra_syntax/src/ast/generated/tokens.rs";
28 27
29const ASSISTS_DIR: &str = "crates/ra_assists/src/handlers"; 28const ASSISTS_DIR: &str = "crates/ra_assists/src/handlers";
30const ASSISTS_TESTS: &str = "crates/ra_assists/src/doc_tests/generated.rs"; 29const ASSISTS_TESTS: &str = "crates/ra_assists/src/doc_tests/generated.rs";
diff --git a/xtask/src/codegen/gen_syntax.rs b/xtask/src/codegen/gen_syntax.rs
index 4c9e447a3..ce18f2b8f 100644
--- a/xtask/src/codegen/gen_syntax.rs
+++ b/xtask/src/codegen/gen_syntax.rs
@@ -3,10 +3,7 @@
3//! Specifically, it generates the `SyntaxKind` enum and a number of newtype 3//! Specifically, it generates the `SyntaxKind` enum and a number of newtype
4//! wrappers around `SyntaxNode` which implement `ra_syntax::AstNode`. 4//! wrappers around `SyntaxNode` which implement `ra_syntax::AstNode`.
5 5
6use std::{ 6use std::collections::{BTreeSet, HashSet};
7 borrow::Cow,
8 collections::{BTreeSet, HashSet},
9};
10 7
11use proc_macro2::{Punct, Spacing}; 8use proc_macro2::{Punct, Spacing};
12use quote::{format_ident, quote}; 9use quote::{format_ident, quote};
@@ -26,10 +23,6 @@ pub fn generate_syntax(mode: Mode) -> Result<()> {
26 let contents = generate_nodes(KINDS_SRC, AST_SRC)?; 23 let contents = generate_nodes(KINDS_SRC, AST_SRC)?;
27 update(ast_nodes_file.as_path(), &contents, mode)?; 24 update(ast_nodes_file.as_path(), &contents, mode)?;
28 25
29 let ast_tokens_file = project_root().join(codegen::AST_TOKENS);
30 let contents = generate_tokens(KINDS_SRC, AST_SRC)?;
31 update(ast_tokens_file.as_path(), &contents, mode)?;
32
33 Ok(()) 26 Ok(())
34} 27}
35 28
@@ -40,147 +33,7 @@ struct ElementKinds {
40 has_tokens: bool, 33 has_tokens: bool,
41} 34}
42 35
43fn generate_tokens(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> {
44 let all_token_kinds: Vec<_> = kinds
45 .punct
46 .into_iter()
47 .map(|(_, kind)| kind)
48 .copied()
49 .map(|x| x.into())
50 .chain(
51 kinds
52 .keywords
53 .into_iter()
54 .chain(kinds.contextual_keywords.into_iter())
55 .map(|name| Cow::Owned(format!("{}_KW", to_upper_snake_case(&name)))),
56 )
57 .chain(kinds.literals.into_iter().copied().map(|x| x.into()))
58 .chain(kinds.tokens.into_iter().copied().map(|x| x.into()))
59 .collect();
60
61 let tokens = all_token_kinds.iter().filter_map(|kind_str| {
62 if kind_str.ends_with("_KW") {
63 return None;
64 }
65 let kind_str = &**kind_str;
66 let kind = format_ident!("{}", kind_str);
67 let name = format_ident!("{}", to_pascal_case(kind_str));
68 let res = quote! {
69 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
70 pub struct #name {
71 pub(crate) syntax: SyntaxToken,
72 }
73
74 impl std::fmt::Display for #name {
75 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
76 std::fmt::Display::fmt(&self.syntax, f)
77 }
78 }
79
80 impl AstToken for #name {
81 fn can_cast(kind: SyntaxKind) -> bool { kind == #kind }
82 fn cast(syntax: SyntaxToken) -> Option<Self> {
83 if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
84 }
85 fn syntax(&self) -> &SyntaxToken { &self.syntax }
86 }
87 };
88 Some(res)
89 });
90
91 let enums = grammar.token_enums.iter().map(|en| {
92 let variants = en.variants.iter().map(|var| format_ident!("{}", var)).collect::<Vec<_>>();
93 let name = format_ident!("{}", en.name);
94 let kinds = variants
95 .iter()
96 .map(|name| format_ident!("{}", to_upper_snake_case(&name.to_string())))
97 .collect::<Vec<_>>();
98 assert!(en.traits.is_empty());
99
100 quote! {
101 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
102 pub enum #name {
103 #(#variants(#variants),)*
104 }
105
106 #(
107 impl From<#variants> for #name {
108 fn from(node: #variants) -> #name {
109 #name::#variants(node)
110 }
111 }
112 )*
113
114 impl std::fmt::Display for #name {
115 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
116 std::fmt::Display::fmt(self.syntax(), f)
117 }
118 }
119
120 impl AstToken for #name {
121 fn can_cast(kind: SyntaxKind) -> bool {
122 match kind {
123 #(#kinds)|* => true,
124 _ => false,
125 }
126 }
127 fn cast(syntax: SyntaxToken) -> Option<Self> {
128 let res = match syntax.kind() {
129 #(
130 #kinds => #name::#variants(#variants { syntax }),
131 )*
132 _ => return None,
133 };
134 Some(res)
135 }
136 fn syntax(&self) -> &SyntaxToken {
137 match self {
138 #(
139 #name::#variants(it) => &it.syntax,
140 )*
141 }
142 }
143 }
144 }
145 });
146
147 crate::reformat(quote! {
148 use crate::{SyntaxToken, SyntaxKind::{self, *}, ast::AstToken};
149
150 #(#tokens)*
151 #(#enums)*
152 })
153}
154
155fn generate_nodes(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> { 36fn generate_nodes(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> {
156 let all_token_kinds: Vec<_> = kinds
157 .punct
158 .into_iter()
159 .map(|(_, kind)| kind)
160 .copied()
161 .map(|x| x.into())
162 .chain(
163 kinds
164 .keywords
165 .into_iter()
166 .chain(kinds.contextual_keywords.into_iter())
167 .map(|name| Cow::Owned(format!("{}_KW", to_upper_snake_case(&name)))),
168 )
169 .chain(kinds.literals.into_iter().copied().map(|x| x.into()))
170 .chain(kinds.tokens.into_iter().copied().map(|x| x.into()))
171 .collect();
172
173 let mut token_kinds = HashSet::new();
174 for kind in &all_token_kinds {
175 let kind = &**kind;
176 let name = to_pascal_case(kind);
177 token_kinds.insert(name);
178 }
179
180 for en in grammar.token_enums {
181 token_kinds.insert(en.name.to_string());
182 }
183
184 let nodes = grammar.nodes.iter().map(|node| { 37 let nodes = grammar.nodes.iter().map(|node| {
185 let name = format_ident!("{}", node.name); 38 let name = format_ident!("{}", node.name);
186 let kind = format_ident!("{}", to_upper_snake_case(&name.to_string())); 39 let kind = format_ident!("{}", to_upper_snake_case(&name.to_string()));
@@ -207,19 +60,9 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> {
207 } 60 }
208 } 61 }
209 } else { 62 } else {
210 let is_token = token_kinds.contains(&ty.to_string()); 63 quote! {
211 if is_token { 64 pub fn #method_name(&self) -> Option<#ty> {
212 let method_name = format_ident!("{}_token", method_name); 65 support::child(&self.syntax)
213 quote! {
214 pub fn #method_name(&self) -> Option<#ty> {
215 support::token(&self.syntax)
216 }
217 }
218 } else {
219 quote! {
220 pub fn #method_name(&self) -> Option<#ty> {
221 support::child(&self.syntax)
222 }
223 } 66 }
224 } 67 }
225 } 68 }
@@ -338,8 +181,6 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> {
338 T, 181 T,
339 }; 182 };
340 183
341 use super::tokens::*;
342
343 #(#nodes)* 184 #(#nodes)*
344 #(#enums)* 185 #(#enums)*
345 #(#displays)* 186 #(#displays)*
@@ -456,6 +297,8 @@ fn generate_syntax_kinds(grammar: KindsSrc<'_>) -> Result<String> {
456 macro_rules! T { 297 macro_rules! T {
457 #((#punctuation_values) => { $crate::SyntaxKind::#punctuation };)* 298 #((#punctuation_values) => { $crate::SyntaxKind::#punctuation };)*
458 #((#all_keywords_idents) => { $crate::SyntaxKind::#all_keywords };)* 299 #((#all_keywords_idents) => { $crate::SyntaxKind::#all_keywords };)*
300 (lifetime) => { $crate::SyntaxKind::LIFETIME };
301 (ident) => { $crate::SyntaxKind::IDENT };
459 } 302 }
460 }; 303 };
461 304
@@ -535,8 +378,21 @@ impl Field<'_> {
535 "')'" => "r_paren", 378 "')'" => "r_paren",
536 "'['" => "l_brack", 379 "'['" => "l_brack",
537 "']'" => "r_brack", 380 "']'" => "r_brack",
381 "<" => "l_angle",
382 ">" => "r_angle",
538 "=" => "eq", 383 "=" => "eq",
539 "!" => "excl", 384 "!" => "excl",
385 "*" => "star",
386 "&" => "amp",
387 "_" => "underscore",
388 "." => "dot",
389 ".." => "dotdot",
390 "..." => "dotdotdot",
391 "=>" => "fat_arrow",
392 "@" => "at",
393 ":" => "colon",
394 "::" => "coloncolon",
395 "#" => "pound",
540 _ => name, 396 _ => name,
541 }; 397 };
542 format_ident!("{}_token", name) 398 format_ident!("{}_token", name)
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-05 11:55:37 +0100