From a95116fbfa11cad4e03b8b31f8d4498f3ddd5d9e Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Thu, 9 Apr 2020 18:20:06 +0200
Subject: Simplify

---
 crates/ra_syntax/src/ast/extensions.rs | 39 ++++++++++++----------------------
 1 file changed, 13 insertions(+), 26 deletions(-)

(limited to 'crates/ra_syntax')

diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs
index 33fe60762..c7df15662 100644
--- a/crates/ra_syntax/src/ast/extensions.rs
+++ b/crates/ra_syntax/src/ast/extensions.rs
@@ -2,16 +2,14 @@
 //! Extensions for various expressions live in a sibling `expr_extensions` module.
 
 use itertools::Itertools;
+use ra_parser::SyntaxKind;
 
 use crate::{
     ast::{
         self, child_opt, children, support, AstNode, AstToken, AttrInput, NameOwner, SyntaxNode,
     },
-    SmolStr, SyntaxElement,
-    SyntaxKind::*,
-    SyntaxToken, T,
+    SmolStr, SyntaxElement, SyntaxToken, T,
 };
-use ra_parser::SyntaxKind;
 
 impl ast::Name {
     pub fn text(&self) -> &SmolStr {
@@ -25,13 +23,11 @@ impl ast::NameRef {
     }
 
     pub fn as_tuple_field(&self) -> Option<usize> {
-        self.syntax().children_with_tokens().find_map(|c| {
-            if c.kind() == SyntaxKind::INT_NUMBER {
-                c.as_token().and_then(|tok| tok.text().as_str().parse().ok())
-            } else {
-                None
-            }
-        })
+        if let Some(ast::NameRefToken::IntNumber(token)) = self.name_ref_token() {
+            token.text().as_str().parse().ok()
+        } else {
+            None
+        }
     }
 }
 
@@ -142,10 +138,7 @@ impl ast::Path {
 
 impl ast::Module {
     pub fn has_semi(&self) -> bool {
-        match self.syntax().last_child_or_token() {
-            None => false,
-            Some(node) => node.kind() == T![;],
-        }
+        self.semi().is_some()
     }
 }
 
@@ -181,7 +174,7 @@ impl ast::ImplDef {
     }
 
     pub fn is_negative(&self) -> bool {
-        self.syntax().children_with_tokens().any(|t| t.kind() == T![!])
+        self.excl().is_some()
     }
 }
 
@@ -225,14 +218,11 @@ impl ast::EnumVariant {
 
 impl ast::FnDef {
     pub fn semicolon_token(&self) -> Option<SyntaxToken> {
-        self.syntax()
-            .last_child_or_token()
-            .and_then(|it| it.into_token())
-            .filter(|it| it.kind() == T![;])
+        Some(self.semi()?.syntax().clone())
     }
 
     pub fn is_async(&self) -> bool {
-        self.syntax().children_with_tokens().any(|it| it.kind() == T![async])
+        self.async_kw().is_some()
     }
 }
 
@@ -245,16 +235,13 @@ impl ast::LetStmt {
     }
 
     pub fn eq_token(&self) -> Option<SyntaxToken> {
-        self.syntax().children_with_tokens().find(|t| t.kind() == EQ).and_then(|it| it.into_token())
+        Some(self.eq()?.syntax().clone())
     }
 }
 
 impl ast::ExprStmt {
     pub fn has_semi(&self) -> bool {
-        match self.syntax().last_child_or_token() {
-            None => false,
-            Some(node) => node.kind() == T![;],
-        }
+        self.semi().is_some()
     }
 }
 
-- 
cgit v1.2.3


From e6d22187a67e762bb950de244a6ca15f3a0b0731 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Thu, 9 Apr 2020 18:25:36 +0200
Subject: Add _token suffix to token accessors

I think this makes is more clear which things are : AstNode and which
are : AstToken
---
 crates/ra_syntax/src/ast.rs                 |   2 +-
 crates/ra_syntax/src/ast/edit.rs            |   6 +-
 crates/ra_syntax/src/ast/extensions.rs      |  22 +-
 crates/ra_syntax/src/ast/generated/nodes.rs | 376 ++++++++++++++--------------
 4 files changed, 201 insertions(+), 205 deletions(-)

(limited to 'crates/ra_syntax')

diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index a42eec91a..15a8279f3 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -287,7 +287,7 @@ where
     let pred = predicates.next().unwrap();
     let mut bounds = pred.type_bound_list().unwrap().bounds();
 
-    assert_eq!("'a", pred.lifetime().unwrap().text());
+    assert_eq!("'a", pred.lifetime_token().unwrap().text());
 
     assert_bound("'b", bounds.next());
     assert_bound("'c", bounds.next());
diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs
index d79310995..62153f199 100644
--- a/crates/ra_syntax/src/ast/edit.rs
+++ b/crates/ra_syntax/src/ast/edit.rs
@@ -96,7 +96,7 @@ impl ast::ItemList {
                 leading_indent(it.syntax()).unwrap_or_default().to_string(),
                 InsertPosition::After(it.syntax().clone().into()),
             ),
-            None => match self.l_curly() {
+            None => match self.l_curly_token() {
                 Some(it) => (
                     "    ".to_string() + &leading_indent(self.syntax()).unwrap_or_default(),
                     InsertPosition::After(it.syntax().clone().into()),
@@ -142,7 +142,7 @@ impl ast::RecordFieldList {
 
         macro_rules! after_l_curly {
             () => {{
-                let anchor = match self.l_curly() {
+                let anchor = match self.l_curly_token() {
                     Some(it) => it.syntax().clone().into(),
                     None => return self.clone(),
                 };
@@ -301,7 +301,7 @@ impl ast::UseTree {
             suffix.clone(),
             self.use_tree_list(),
             self.alias(),
-            self.star().is_some(),
+            self.star_token().is_some(),
         );
         let nested = make::use_tree_list(iter::once(use_tree));
         return make::use_tree(prefix.clone(), Some(nested), None, false);
diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs
index c7df15662..ff3525c84 100644
--- a/crates/ra_syntax/src/ast/extensions.rs
+++ b/crates/ra_syntax/src/ast/extensions.rs
@@ -23,7 +23,7 @@ impl ast::NameRef {
     }
 
     pub fn as_tuple_field(&self) -> Option<usize> {
-        if let Some(ast::NameRefToken::IntNumber(token)) = self.name_ref_token() {
+        if let Some(ast::NameRefToken::IntNumber(token)) = self.name_ref_token_token() {
             token.text().as_str().parse().ok()
         } else {
             None
@@ -138,7 +138,7 @@ impl ast::Path {
 
 impl ast::Module {
     pub fn has_semi(&self) -> bool {
-        self.semi().is_some()
+        self.semi_token().is_some()
     }
 }
 
@@ -174,7 +174,7 @@ impl ast::ImplDef {
     }
 
     pub fn is_negative(&self) -> bool {
-        self.excl().is_some()
+        self.excl_token().is_some()
     }
 }
 
@@ -218,11 +218,11 @@ impl ast::EnumVariant {
 
 impl ast::FnDef {
     pub fn semicolon_token(&self) -> Option<SyntaxToken> {
-        Some(self.semi()?.syntax().clone())
+        Some(self.semi_token()?.syntax().clone())
     }
 
     pub fn is_async(&self) -> bool {
-        self.async_kw().is_some()
+        self.async_kw_token().is_some()
     }
 }
 
@@ -233,15 +233,11 @@ impl ast::LetStmt {
             Some(node) => node.kind() == T![;],
         }
     }
-
-    pub fn eq_token(&self) -> Option<SyntaxToken> {
-        Some(self.eq()?.syntax().clone())
-    }
 }
 
 impl ast::ExprStmt {
     pub fn has_semi(&self) -> bool {
-        self.semi().is_some()
+        self.semi_token().is_some()
     }
 }
 
@@ -350,7 +346,7 @@ pub enum SelfParamKind {
 
 impl ast::SelfParam {
     pub fn kind(&self) -> SelfParamKind {
-        if self.amp().is_some() {
+        if self.amp_token().is_some() {
             if self.amp_mut_kw().is_some() {
                 SelfParamKind::MutRef
             } else {
@@ -396,7 +392,7 @@ impl ast::TypeBound {
             TypeBoundKind::PathType(path_type)
         } else if let Some(for_type) = children(self).next() {
             TypeBoundKind::ForType(for_type)
-        } else if let Some(lifetime) = self.lifetime() {
+        } else if let Some(lifetime) = self.lifetime_token() {
             TypeBoundKind::Lifetime(lifetime)
         } else {
             unreachable!()
@@ -416,7 +412,7 @@ impl ast::TypeBound {
     }
 
     pub fn question(&self) -> Option<ast::Question> {
-        if self.const_kw().is_some() {
+        if self.const_kw_token().is_some() {
             self.syntax()
                 .children_with_tokens()
                 .filter_map(|it| it.into_token())
diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs
index 8b348ad6e..0bcb7fe61 100644
--- a/crates/ra_syntax/src/ast/generated/nodes.rs
+++ b/crates/ra_syntax/src/ast/generated/nodes.rs
@@ -49,15 +49,15 @@ impl ast::DocCommentsOwner for FnDef {}
 impl ast::AttrsOwner for FnDef {}
 impl FnDef {
     pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
-    pub fn const_kw(&self) -> Option<ConstKw> { support::token(&self.syntax) }
-    pub fn default_kw(&self) -> Option<DefaultKw> { support::token(&self.syntax) }
-    pub fn async_kw(&self) -> Option<AsyncKw> { support::token(&self.syntax) }
-    pub fn unsafe_kw(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
-    pub fn fn_kw(&self) -> Option<FnKw> { support::token(&self.syntax) }
+    pub fn const_kw_token(&self) -> Option<ConstKw> { support::token(&self.syntax) }
+    pub fn default_kw_token(&self) -> Option<DefaultKw> { support::token(&self.syntax) }
+    pub fn async_kw_token(&self) -> Option<AsyncKw> { support::token(&self.syntax) }
+    pub fn unsafe_kw_token(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
+    pub fn fn_kw_token(&self) -> Option<FnKw> { support::token(&self.syntax) }
     pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
     pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
     pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
-    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
+    pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RetType {
@@ -75,7 +75,7 @@ impl AstNode for RetType {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl RetType {
-    pub fn thin_arrow(&self) -> Option<ThinArrow> { support::token(&self.syntax) }
+    pub fn thin_arrow_token(&self) -> Option<ThinArrow> { support::token(&self.syntax) }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -99,9 +99,9 @@ impl ast::TypeParamsOwner for StructDef {}
 impl ast::AttrsOwner for StructDef {}
 impl ast::DocCommentsOwner for StructDef {}
 impl StructDef {
-    pub fn struct_kw(&self) -> Option<StructKw> { support::token(&self.syntax) }
+    pub fn struct_kw_token(&self) -> Option<StructKw> { support::token(&self.syntax) }
     pub fn field_def_list(&self) -> Option<FieldDefList> { support::child(&self.syntax) }
-    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
+    pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct UnionDef {
@@ -124,7 +124,7 @@ impl ast::TypeParamsOwner for UnionDef {}
 impl ast::AttrsOwner for UnionDef {}
 impl ast::DocCommentsOwner for UnionDef {}
 impl UnionDef {
-    pub fn union_kw(&self) -> Option<UnionKw> { support::token(&self.syntax) }
+    pub fn union_kw_token(&self) -> Option<UnionKw> { support::token(&self.syntax) }
     pub fn record_field_def_list(&self) -> Option<RecordFieldDefList> {
         support::child(&self.syntax)
     }
@@ -145,9 +145,9 @@ impl AstNode for RecordFieldDefList {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl RecordFieldDefList {
-    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) }
     pub fn fields(&self) -> AstChildren<RecordFieldDef> { support::children(&self.syntax) }
-    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
+    pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RecordFieldDef {
@@ -186,9 +186,9 @@ impl AstNode for TupleFieldDefList {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl TupleFieldDefList {
-    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) }
     pub fn fields(&self) -> AstChildren<TupleFieldDef> { support::children(&self.syntax) }
-    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
+    pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TupleFieldDef {
@@ -231,7 +231,7 @@ impl ast::TypeParamsOwner for EnumDef {}
 impl ast::AttrsOwner for EnumDef {}
 impl ast::DocCommentsOwner for EnumDef {}
 impl EnumDef {
-    pub fn enum_kw(&self) -> Option<EnumKw> { support::token(&self.syntax) }
+    pub fn enum_kw_token(&self) -> Option<EnumKw> { support::token(&self.syntax) }
     pub fn variant_list(&self) -> Option<EnumVariantList> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -250,9 +250,9 @@ impl AstNode for EnumVariantList {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl EnumVariantList {
-    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) }
     pub fn variants(&self) -> AstChildren<EnumVariant> { support::children(&self.syntax) }
-    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
+    pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct EnumVariant {
@@ -275,7 +275,7 @@ impl ast::DocCommentsOwner for EnumVariant {}
 impl ast::AttrsOwner for EnumVariant {}
 impl EnumVariant {
     pub fn field_def_list(&self) -> Option<FieldDefList> { support::child(&self.syntax) }
-    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -300,9 +300,9 @@ impl ast::DocCommentsOwner for TraitDef {}
 impl ast::TypeParamsOwner for TraitDef {}
 impl ast::TypeBoundsOwner for TraitDef {}
 impl TraitDef {
-    pub fn unsafe_kw(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
-    pub fn auto_kw(&self) -> Option<AutoKw> { support::token(&self.syntax) }
-    pub fn trait_kw(&self) -> Option<TraitKw> { support::token(&self.syntax) }
+    pub fn unsafe_kw_token(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
+    pub fn auto_kw_token(&self) -> Option<AutoKw> { support::token(&self.syntax) }
+    pub fn trait_kw_token(&self) -> Option<TraitKw> { support::token(&self.syntax) }
     pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -325,9 +325,9 @@ impl ast::NameOwner for Module {}
 impl ast::AttrsOwner for Module {}
 impl ast::DocCommentsOwner for Module {}
 impl Module {
-    pub fn mod_kw(&self) -> Option<ModKw> { support::token(&self.syntax) }
+    pub fn mod_kw_token(&self) -> Option<ModKw> { support::token(&self.syntax) }
     pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
-    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
+    pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ItemList {
@@ -347,9 +347,9 @@ impl AstNode for ItemList {
 impl ast::FnDefOwner for ItemList {}
 impl ast::ModuleItemOwner for ItemList {}
 impl ItemList {
-    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) }
     pub fn impl_items(&self) -> AstChildren<ImplItem> { support::children(&self.syntax) }
-    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
+    pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ConstDef {
@@ -373,11 +373,11 @@ impl ast::AttrsOwner for ConstDef {}
 impl ast::DocCommentsOwner for ConstDef {}
 impl ast::TypeAscriptionOwner for ConstDef {}
 impl ConstDef {
-    pub fn default_kw(&self) -> Option<DefaultKw> { support::token(&self.syntax) }
-    pub fn const_kw(&self) -> Option<ConstKw> { support::token(&self.syntax) }
-    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn default_kw_token(&self) -> Option<DefaultKw> { support::token(&self.syntax) }
+    pub fn const_kw_token(&self) -> Option<ConstKw> { support::token(&self.syntax) }
+    pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
     pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
-    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
+    pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct StaticDef {
@@ -401,11 +401,11 @@ impl ast::AttrsOwner for StaticDef {}
 impl ast::DocCommentsOwner for StaticDef {}
 impl ast::TypeAscriptionOwner for StaticDef {}
 impl StaticDef {
-    pub fn static_kw(&self) -> Option<StaticKw> { support::token(&self.syntax) }
-    pub fn mut_kw(&self) -> Option<MutKw> { support::token(&self.syntax) }
-    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn static_kw_token(&self) -> Option<StaticKw> { support::token(&self.syntax) }
+    pub fn mut_kw_token(&self) -> Option<MutKw> { support::token(&self.syntax) }
+    pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
     pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
-    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
+    pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TypeAliasDef {
@@ -429,11 +429,11 @@ impl ast::AttrsOwner for TypeAliasDef {}
 impl ast::DocCommentsOwner for TypeAliasDef {}
 impl ast::TypeBoundsOwner for TypeAliasDef {}
 impl TypeAliasDef {
-    pub fn default_kw(&self) -> Option<DefaultKw> { support::token(&self.syntax) }
-    pub fn type_kw(&self) -> Option<TypeKw> { support::token(&self.syntax) }
-    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn default_kw_token(&self) -> Option<DefaultKw> { support::token(&self.syntax) }
+    pub fn type_kw_token(&self) -> Option<TypeKw> { support::token(&self.syntax) }
+    pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
-    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
+    pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ImplDef {
@@ -453,12 +453,12 @@ impl AstNode for ImplDef {
 impl ast::TypeParamsOwner for ImplDef {}
 impl ast::AttrsOwner for ImplDef {}
 impl ImplDef {
-    pub fn default_kw(&self) -> Option<DefaultKw> { support::token(&self.syntax) }
-    pub fn const_kw(&self) -> Option<ConstKw> { support::token(&self.syntax) }
-    pub fn unsafe_kw(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
-    pub fn impl_kw(&self) -> Option<ImplKw> { support::token(&self.syntax) }
-    pub fn excl(&self) -> Option<Excl> { support::token(&self.syntax) }
-    pub fn for_kw(&self) -> Option<ForKw> { support::token(&self.syntax) }
+    pub fn default_kw_token(&self) -> Option<DefaultKw> { support::token(&self.syntax) }
+    pub fn const_kw_token(&self) -> Option<ConstKw> { support::token(&self.syntax) }
+    pub fn unsafe_kw_token(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
+    pub fn impl_kw_token(&self) -> Option<ImplKw> { support::token(&self.syntax) }
+    pub fn excl_token(&self) -> Option<Excl> { support::token(&self.syntax) }
+    pub fn for_kw_token(&self) -> Option<ForKw> { support::token(&self.syntax) }
     pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -477,9 +477,9 @@ impl AstNode for ParenType {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ParenType {
-    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
-    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
+    pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TupleType {
@@ -497,9 +497,9 @@ impl AstNode for TupleType {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl TupleType {
-    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) }
     pub fn fields(&self) -> AstChildren<TypeRef> { support::children(&self.syntax) }
-    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
+    pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct NeverType {
@@ -517,7 +517,7 @@ impl AstNode for NeverType {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl NeverType {
-    pub fn excl(&self) -> Option<Excl> { support::token(&self.syntax) }
+    pub fn excl_token(&self) -> Option<Excl> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PathType {
@@ -553,8 +553,8 @@ impl AstNode for PointerType {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl PointerType {
-    pub fn star(&self) -> Option<Star> { support::token(&self.syntax) }
-    pub fn const_kw(&self) -> Option<ConstKw> { support::token(&self.syntax) }
+    pub fn star_token(&self) -> Option<Star> { support::token(&self.syntax) }
+    pub fn const_kw_token(&self) -> Option<ConstKw> { support::token(&self.syntax) }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -573,11 +573,11 @@ impl AstNode for ArrayType {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ArrayType {
-    pub fn l_brack(&self) -> Option<LBrack> { support::token(&self.syntax) }
+    pub fn l_brack_token(&self) -> Option<LBrack> { support::token(&self.syntax) }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
-    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
+    pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
-    pub fn r_brack(&self) -> Option<RBrack> { support::token(&self.syntax) }
+    pub fn r_brack_token(&self) -> Option<RBrack> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SliceType {
@@ -595,9 +595,9 @@ impl AstNode for SliceType {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl SliceType {
-    pub fn l_brack(&self) -> Option<LBrack> { support::token(&self.syntax) }
+    pub fn l_brack_token(&self) -> Option<LBrack> { support::token(&self.syntax) }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
-    pub fn r_brack(&self) -> Option<RBrack> { support::token(&self.syntax) }
+    pub fn r_brack_token(&self) -> Option<RBrack> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ReferenceType {
@@ -615,9 +615,9 @@ impl AstNode for ReferenceType {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ReferenceType {
-    pub fn amp(&self) -> Option<Amp> { support::token(&self.syntax) }
-    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
-    pub fn mut_kw(&self) -> Option<MutKw> { support::token(&self.syntax) }
+    pub fn amp_token(&self) -> Option<Amp> { support::token(&self.syntax) }
+    pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) }
+    pub fn mut_kw_token(&self) -> Option<MutKw> { support::token(&self.syntax) }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -636,7 +636,7 @@ impl AstNode for PlaceholderType {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl PlaceholderType {
-    pub fn underscore(&self) -> Option<Underscore> { support::token(&self.syntax) }
+    pub fn underscore_token(&self) -> Option<Underscore> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FnPointerType {
@@ -655,8 +655,8 @@ impl AstNode for FnPointerType {
 }
 impl FnPointerType {
     pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
-    pub fn unsafe_kw(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
-    pub fn fn_kw(&self) -> Option<FnKw> { support::token(&self.syntax) }
+    pub fn unsafe_kw_token(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
+    pub fn fn_kw_token(&self) -> Option<FnKw> { support::token(&self.syntax) }
     pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
     pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
 }
@@ -676,7 +676,7 @@ impl AstNode for ForType {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ForType {
-    pub fn for_kw(&self) -> Option<ForKw> { support::token(&self.syntax) }
+    pub fn for_kw_token(&self) -> Option<ForKw> { support::token(&self.syntax) }
     pub fn type_param_list(&self) -> Option<TypeParamList> { support::child(&self.syntax) }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
@@ -697,7 +697,7 @@ impl AstNode for ImplTraitType {
 }
 impl ast::TypeBoundsOwner for ImplTraitType {}
 impl ImplTraitType {
-    pub fn impl_kw(&self) -> Option<ImplKw> { support::token(&self.syntax) }
+    pub fn impl_kw_token(&self) -> Option<ImplKw> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct DynTraitType {
@@ -716,7 +716,7 @@ impl AstNode for DynTraitType {
 }
 impl ast::TypeBoundsOwner for DynTraitType {}
 impl DynTraitType {
-    pub fn dyn_kw(&self) -> Option<DynKw> { support::token(&self.syntax) }
+    pub fn dyn_kw_token(&self) -> Option<DynKw> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TupleExpr {
@@ -735,9 +735,9 @@ impl AstNode for TupleExpr {
 }
 impl ast::AttrsOwner for TupleExpr {}
 impl TupleExpr {
-    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) }
     pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
-    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
+    pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ArrayExpr {
@@ -756,10 +756,10 @@ impl AstNode for ArrayExpr {
 }
 impl ast::AttrsOwner for ArrayExpr {}
 impl ArrayExpr {
-    pub fn l_brack(&self) -> Option<LBrack> { support::token(&self.syntax) }
+    pub fn l_brack_token(&self) -> Option<LBrack> { support::token(&self.syntax) }
     pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
-    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
-    pub fn r_brack(&self) -> Option<RBrack> { support::token(&self.syntax) }
+    pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) }
+    pub fn r_brack_token(&self) -> Option<RBrack> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ParenExpr {
@@ -778,9 +778,9 @@ impl AstNode for ParenExpr {
 }
 impl ast::AttrsOwner for ParenExpr {}
 impl ParenExpr {
-    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
-    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
+    pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PathExpr {
@@ -817,9 +817,9 @@ impl AstNode for LambdaExpr {
 }
 impl ast::AttrsOwner for LambdaExpr {}
 impl LambdaExpr {
-    pub fn static_kw(&self) -> Option<StaticKw> { support::token(&self.syntax) }
-    pub fn async_kw(&self) -> Option<AsyncKw> { support::token(&self.syntax) }
-    pub fn move_kw(&self) -> Option<MoveKw> { support::token(&self.syntax) }
+    pub fn static_kw_token(&self) -> Option<StaticKw> { support::token(&self.syntax) }
+    pub fn async_kw_token(&self) -> Option<AsyncKw> { support::token(&self.syntax) }
+    pub fn move_kw_token(&self) -> Option<MoveKw> { support::token(&self.syntax) }
     pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
     pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
     pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
@@ -841,7 +841,7 @@ impl AstNode for IfExpr {
 }
 impl ast::AttrsOwner for IfExpr {}
 impl IfExpr {
-    pub fn if_kw(&self) -> Option<IfKw> { support::token(&self.syntax) }
+    pub fn if_kw_token(&self) -> Option<IfKw> { support::token(&self.syntax) }
     pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -862,7 +862,7 @@ impl AstNode for LoopExpr {
 impl ast::AttrsOwner for LoopExpr {}
 impl ast::LoopBodyOwner for LoopExpr {}
 impl LoopExpr {
-    pub fn loop_kw(&self) -> Option<LoopKw> { support::token(&self.syntax) }
+    pub fn loop_kw_token(&self) -> Option<LoopKw> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TryBlockExpr {
@@ -881,7 +881,7 @@ impl AstNode for TryBlockExpr {
 }
 impl ast::AttrsOwner for TryBlockExpr {}
 impl TryBlockExpr {
-    pub fn try_kw(&self) -> Option<TryKw> { support::token(&self.syntax) }
+    pub fn try_kw_token(&self) -> Option<TryKw> { support::token(&self.syntax) }
     pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -902,9 +902,9 @@ impl AstNode for ForExpr {
 impl ast::AttrsOwner for ForExpr {}
 impl ast::LoopBodyOwner for ForExpr {}
 impl ForExpr {
-    pub fn for_kw(&self) -> Option<ForKw> { support::token(&self.syntax) }
+    pub fn for_kw_token(&self) -> Option<ForKw> { support::token(&self.syntax) }
     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
-    pub fn in_kw(&self) -> Option<InKw> { support::token(&self.syntax) }
+    pub fn in_kw_token(&self) -> Option<InKw> { support::token(&self.syntax) }
     pub fn iterable(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -925,7 +925,7 @@ impl AstNode for WhileExpr {
 impl ast::AttrsOwner for WhileExpr {}
 impl ast::LoopBodyOwner for WhileExpr {}
 impl WhileExpr {
-    pub fn while_kw(&self) -> Option<WhileKw> { support::token(&self.syntax) }
+    pub fn while_kw_token(&self) -> Option<WhileKw> { support::token(&self.syntax) }
     pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -945,8 +945,8 @@ impl AstNode for ContinueExpr {
 }
 impl ast::AttrsOwner for ContinueExpr {}
 impl ContinueExpr {
-    pub fn continue_kw(&self) -> Option<ContinueKw> { support::token(&self.syntax) }
-    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
+    pub fn continue_kw_token(&self) -> Option<ContinueKw> { support::token(&self.syntax) }
+    pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct BreakExpr {
@@ -965,8 +965,8 @@ impl AstNode for BreakExpr {
 }
 impl ast::AttrsOwner for BreakExpr {}
 impl BreakExpr {
-    pub fn break_kw(&self) -> Option<BreakKw> { support::token(&self.syntax) }
-    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
+    pub fn break_kw_token(&self) -> Option<BreakKw> { support::token(&self.syntax) }
+    pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -985,7 +985,7 @@ impl AstNode for Label {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl Label {
-    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
+    pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct BlockExpr {
@@ -1005,7 +1005,7 @@ impl AstNode for BlockExpr {
 impl ast::AttrsOwner for BlockExpr {}
 impl BlockExpr {
     pub fn label(&self) -> Option<Label> { support::child(&self.syntax) }
-    pub fn unsafe_kw(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
+    pub fn unsafe_kw_token(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
     pub fn block(&self) -> Option<Block> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1065,7 +1065,7 @@ impl ast::AttrsOwner for MethodCallExpr {}
 impl ast::ArgListOwner for MethodCallExpr {}
 impl MethodCallExpr {
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
-    pub fn dot(&self) -> Option<Dot> { support::token(&self.syntax) }
+    pub fn dot_token(&self) -> Option<Dot> { support::token(&self.syntax) }
     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
     pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) }
 }
@@ -1086,8 +1086,8 @@ impl AstNode for IndexExpr {
 }
 impl ast::AttrsOwner for IndexExpr {}
 impl IndexExpr {
-    pub fn l_brack(&self) -> Option<LBrack> { support::token(&self.syntax) }
-    pub fn r_brack(&self) -> Option<RBrack> { support::token(&self.syntax) }
+    pub fn l_brack_token(&self) -> Option<LBrack> { support::token(&self.syntax) }
+    pub fn r_brack_token(&self) -> Option<RBrack> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FieldExpr {
@@ -1107,7 +1107,7 @@ impl AstNode for FieldExpr {
 impl ast::AttrsOwner for FieldExpr {}
 impl FieldExpr {
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
-    pub fn dot(&self) -> Option<Dot> { support::token(&self.syntax) }
+    pub fn dot_token(&self) -> Option<Dot> { support::token(&self.syntax) }
     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1128,8 +1128,8 @@ impl AstNode for AwaitExpr {
 impl ast::AttrsOwner for AwaitExpr {}
 impl AwaitExpr {
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
-    pub fn dot(&self) -> Option<Dot> { support::token(&self.syntax) }
-    pub fn await_kw(&self) -> Option<AwaitKw> { support::token(&self.syntax) }
+    pub fn dot_token(&self) -> Option<Dot> { support::token(&self.syntax) }
+    pub fn await_kw_token(&self) -> Option<AwaitKw> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TryExpr {
@@ -1148,7 +1148,7 @@ impl AstNode for TryExpr {
 }
 impl ast::AttrsOwner for TryExpr {}
 impl TryExpr {
-    pub fn try_kw(&self) -> Option<TryKw> { support::token(&self.syntax) }
+    pub fn try_kw_token(&self) -> Option<TryKw> { support::token(&self.syntax) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1169,7 +1169,7 @@ impl AstNode for CastExpr {
 impl ast::AttrsOwner for CastExpr {}
 impl CastExpr {
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
-    pub fn as_kw(&self) -> Option<AsKw> { support::token(&self.syntax) }
+    pub fn as_kw_token(&self) -> Option<AsKw> { support::token(&self.syntax) }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1189,9 +1189,9 @@ impl AstNode for RefExpr {
 }
 impl ast::AttrsOwner for RefExpr {}
 impl RefExpr {
-    pub fn amp(&self) -> Option<Amp> { support::token(&self.syntax) }
-    pub fn raw_kw(&self) -> Option<RawKw> { support::token(&self.syntax) }
-    pub fn mut_kw(&self) -> Option<MutKw> { support::token(&self.syntax) }
+    pub fn amp_token(&self) -> Option<Amp> { support::token(&self.syntax) }
+    pub fn raw_kw_token(&self) -> Option<RawKw> { support::token(&self.syntax) }
+    pub fn mut_kw_token(&self) -> Option<MutKw> { support::token(&self.syntax) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1211,7 +1211,7 @@ impl AstNode for PrefixExpr {
 }
 impl ast::AttrsOwner for PrefixExpr {}
 impl PrefixExpr {
-    pub fn prefix_op(&self) -> Option<PrefixOp> { support::token(&self.syntax) }
+    pub fn prefix_op_token(&self) -> Option<PrefixOp> { support::token(&self.syntax) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1231,7 +1231,7 @@ impl AstNode for BoxExpr {
 }
 impl ast::AttrsOwner for BoxExpr {}
 impl BoxExpr {
-    pub fn box_kw(&self) -> Option<BoxKw> { support::token(&self.syntax) }
+    pub fn box_kw_token(&self) -> Option<BoxKw> { support::token(&self.syntax) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1251,7 +1251,7 @@ impl AstNode for RangeExpr {
 }
 impl ast::AttrsOwner for RangeExpr {}
 impl RangeExpr {
-    pub fn range_op(&self) -> Option<RangeOp> { support::token(&self.syntax) }
+    pub fn range_op_token(&self) -> Option<RangeOp> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct BinExpr {
@@ -1270,7 +1270,7 @@ impl AstNode for BinExpr {
 }
 impl ast::AttrsOwner for BinExpr {}
 impl BinExpr {
-    pub fn bin_op(&self) -> Option<BinOp> { support::token(&self.syntax) }
+    pub fn bin_op_token(&self) -> Option<BinOp> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Literal {
@@ -1288,7 +1288,7 @@ impl AstNode for Literal {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl Literal {
-    pub fn literal_token(&self) -> Option<LiteralToken> { support::token(&self.syntax) }
+    pub fn literal_token_token(&self) -> Option<LiteralToken> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MatchExpr {
@@ -1307,7 +1307,7 @@ impl AstNode for MatchExpr {
 }
 impl ast::AttrsOwner for MatchExpr {}
 impl MatchExpr {
-    pub fn match_kw(&self) -> Option<MatchKw> { support::token(&self.syntax) }
+    pub fn match_kw_token(&self) -> Option<MatchKw> { support::token(&self.syntax) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
     pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) }
 }
@@ -1328,9 +1328,9 @@ impl AstNode for MatchArmList {
 }
 impl ast::AttrsOwner for MatchArmList {}
 impl MatchArmList {
-    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) }
     pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) }
-    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
+    pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MatchArm {
@@ -1351,7 +1351,7 @@ impl ast::AttrsOwner for MatchArm {}
 impl MatchArm {
     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
     pub fn guard(&self) -> Option<MatchGuard> { support::child(&self.syntax) }
-    pub fn fat_arrow(&self) -> Option<FatArrow> { support::token(&self.syntax) }
+    pub fn fat_arrow_token(&self) -> Option<FatArrow> { support::token(&self.syntax) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1370,7 +1370,7 @@ impl AstNode for MatchGuard {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl MatchGuard {
-    pub fn if_kw(&self) -> Option<IfKw> { support::token(&self.syntax) }
+    pub fn if_kw_token(&self) -> Option<IfKw> { support::token(&self.syntax) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1408,11 +1408,11 @@ impl AstNode for RecordFieldList {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl RecordFieldList {
-    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) }
     pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) }
-    pub fn dotdot(&self) -> Option<Dotdot> { support::token(&self.syntax) }
+    pub fn dotdot_token(&self) -> Option<Dotdot> { support::token(&self.syntax) }
     pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) }
-    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
+    pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RecordField {
@@ -1432,7 +1432,7 @@ impl AstNode for RecordField {
 impl ast::AttrsOwner for RecordField {}
 impl RecordField {
     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
-    pub fn colon(&self) -> Option<Colon> { support::token(&self.syntax) }
+    pub fn colon_token(&self) -> Option<Colon> { support::token(&self.syntax) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1469,9 +1469,9 @@ impl AstNode for ParenPat {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ParenPat {
-    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) }
     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
-    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
+    pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RefPat {
@@ -1489,8 +1489,8 @@ impl AstNode for RefPat {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl RefPat {
-    pub fn amp(&self) -> Option<Amp> { support::token(&self.syntax) }
-    pub fn mut_kw(&self) -> Option<MutKw> { support::token(&self.syntax) }
+    pub fn amp_token(&self) -> Option<Amp> { support::token(&self.syntax) }
+    pub fn mut_kw_token(&self) -> Option<MutKw> { support::token(&self.syntax) }
     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1509,7 +1509,7 @@ impl AstNode for BoxPat {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl BoxPat {
-    pub fn box_kw(&self) -> Option<BoxKw> { support::token(&self.syntax) }
+    pub fn box_kw_token(&self) -> Option<BoxKw> { support::token(&self.syntax) }
     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1530,8 +1530,8 @@ impl AstNode for BindPat {
 impl ast::AttrsOwner for BindPat {}
 impl ast::NameOwner for BindPat {}
 impl BindPat {
-    pub fn ref_kw(&self) -> Option<RefKw> { support::token(&self.syntax) }
-    pub fn mut_kw(&self) -> Option<MutKw> { support::token(&self.syntax) }
+    pub fn ref_kw_token(&self) -> Option<RefKw> { support::token(&self.syntax) }
+    pub fn mut_kw_token(&self) -> Option<MutKw> { support::token(&self.syntax) }
     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1550,7 +1550,7 @@ impl AstNode for PlaceholderPat {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl PlaceholderPat {
-    pub fn underscore(&self) -> Option<Underscore> { support::token(&self.syntax) }
+    pub fn underscore_token(&self) -> Option<Underscore> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct DotDotPat {
@@ -1568,7 +1568,7 @@ impl AstNode for DotDotPat {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl DotDotPat {
-    pub fn dotdot(&self) -> Option<Dotdot> { support::token(&self.syntax) }
+    pub fn dotdot_token(&self) -> Option<Dotdot> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PathPat {
@@ -1604,9 +1604,9 @@ impl AstNode for SlicePat {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl SlicePat {
-    pub fn l_brack(&self) -> Option<LBrack> { support::token(&self.syntax) }
+    pub fn l_brack_token(&self) -> Option<LBrack> { support::token(&self.syntax) }
     pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
-    pub fn r_brack(&self) -> Option<RBrack> { support::token(&self.syntax) }
+    pub fn r_brack_token(&self) -> Option<RBrack> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RangePat {
@@ -1624,7 +1624,7 @@ impl AstNode for RangePat {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl RangePat {
-    pub fn range_separator(&self) -> Option<RangeSeparator> { support::token(&self.syntax) }
+    pub fn range_separator_token(&self) -> Option<RangeSeparator> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LiteralPat {
@@ -1699,14 +1699,14 @@ impl AstNode for RecordFieldPatList {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl RecordFieldPatList {
-    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) }
     pub fn pats(&self) -> AstChildren<RecordInnerPat> { support::children(&self.syntax) }
     pub fn record_field_pats(&self) -> AstChildren<RecordFieldPat> {
         support::children(&self.syntax)
     }
     pub fn bind_pats(&self) -> AstChildren<BindPat> { support::children(&self.syntax) }
-    pub fn dotdot(&self) -> Option<Dotdot> { support::token(&self.syntax) }
-    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
+    pub fn dotdot_token(&self) -> Option<Dotdot> { support::token(&self.syntax) }
+    pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RecordFieldPat {
@@ -1726,7 +1726,7 @@ impl AstNode for RecordFieldPat {
 impl ast::AttrsOwner for RecordFieldPat {}
 impl ast::NameOwner for RecordFieldPat {}
 impl RecordFieldPat {
-    pub fn colon(&self) -> Option<Colon> { support::token(&self.syntax) }
+    pub fn colon_token(&self) -> Option<Colon> { support::token(&self.syntax) }
     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1746,9 +1746,9 @@ impl AstNode for TupleStructPat {
 }
 impl TupleStructPat {
     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
-    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) }
     pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
-    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
+    pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TuplePat {
@@ -1766,9 +1766,9 @@ impl AstNode for TuplePat {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl TuplePat {
-    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) }
     pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
-    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
+    pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Visibility {
@@ -1786,10 +1786,10 @@ impl AstNode for Visibility {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl Visibility {
-    pub fn pub_kw(&self) -> Option<PubKw> { support::token(&self.syntax) }
-    pub fn super_kw(&self) -> Option<SuperKw> { support::token(&self.syntax) }
-    pub fn self_kw(&self) -> Option<SelfKw> { support::token(&self.syntax) }
-    pub fn crate_kw(&self) -> Option<CrateKw> { support::token(&self.syntax) }
+    pub fn pub_kw_token(&self) -> Option<PubKw> { support::token(&self.syntax) }
+    pub fn super_kw_token(&self) -> Option<SuperKw> { support::token(&self.syntax) }
+    pub fn self_kw_token(&self) -> Option<SelfKw> { support::token(&self.syntax) }
+    pub fn crate_kw_token(&self) -> Option<CrateKw> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Name {
@@ -1807,7 +1807,7 @@ impl AstNode for Name {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl Name {
-    pub fn ident(&self) -> Option<Ident> { support::token(&self.syntax) }
+    pub fn ident_token(&self) -> Option<Ident> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct NameRef {
@@ -1825,7 +1825,7 @@ impl AstNode for NameRef {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl NameRef {
-    pub fn name_ref_token(&self) -> Option<NameRefToken> { support::token(&self.syntax) }
+    pub fn name_ref_token_token(&self) -> Option<NameRefToken> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MacroCall {
@@ -1847,9 +1847,9 @@ impl ast::AttrsOwner for MacroCall {}
 impl ast::DocCommentsOwner for MacroCall {}
 impl MacroCall {
     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
-    pub fn excl(&self) -> Option<Excl> { support::token(&self.syntax) }
+    pub fn excl_token(&self) -> Option<Excl> { support::token(&self.syntax) }
     pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
-    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
+    pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Attr {
@@ -1867,13 +1867,13 @@ impl AstNode for Attr {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl Attr {
-    pub fn pound(&self) -> Option<Pound> { support::token(&self.syntax) }
-    pub fn excl(&self) -> Option<Excl> { support::token(&self.syntax) }
-    pub fn l_brack(&self) -> Option<LBrack> { support::token(&self.syntax) }
+    pub fn pound_token(&self) -> Option<Pound> { support::token(&self.syntax) }
+    pub fn excl_token(&self) -> Option<Excl> { support::token(&self.syntax) }
+    pub fn l_brack_token(&self) -> Option<LBrack> { support::token(&self.syntax) }
     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
-    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
     pub fn input(&self) -> Option<AttrInput> { support::child(&self.syntax) }
-    pub fn r_brack(&self) -> Option<RBrack> { support::token(&self.syntax) }
+    pub fn r_brack_token(&self) -> Option<RBrack> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TokenTree {
@@ -1907,12 +1907,12 @@ impl AstNode for TypeParamList {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl TypeParamList {
-    pub fn l_angle(&self) -> Option<LAngle> { support::token(&self.syntax) }
+    pub fn l_angle_token(&self) -> Option<LAngle> { support::token(&self.syntax) }
     pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) }
     pub fn type_params(&self) -> AstChildren<TypeParam> { support::children(&self.syntax) }
     pub fn lifetime_params(&self) -> AstChildren<LifetimeParam> { support::children(&self.syntax) }
     pub fn const_params(&self) -> AstChildren<ConstParam> { support::children(&self.syntax) }
-    pub fn r_angle(&self) -> Option<RAngle> { support::token(&self.syntax) }
+    pub fn r_angle_token(&self) -> Option<RAngle> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TypeParam {
@@ -1933,7 +1933,7 @@ impl ast::NameOwner for TypeParam {}
 impl ast::AttrsOwner for TypeParam {}
 impl ast::TypeBoundsOwner for TypeParam {}
 impl TypeParam {
-    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
     pub fn default_type(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1955,7 +1955,7 @@ impl ast::NameOwner for ConstParam {}
 impl ast::AttrsOwner for ConstParam {}
 impl ast::TypeAscriptionOwner for ConstParam {}
 impl ConstParam {
-    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
     pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1975,7 +1975,7 @@ impl AstNode for LifetimeParam {
 }
 impl ast::AttrsOwner for LifetimeParam {}
 impl LifetimeParam {
-    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
+    pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TypeBound {
@@ -1993,8 +1993,8 @@ impl AstNode for TypeBound {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl TypeBound {
-    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
-    pub fn const_kw(&self) -> Option<ConstKw> { support::token(&self.syntax) }
+    pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) }
+    pub fn const_kw_token(&self) -> Option<ConstKw> { support::token(&self.syntax) }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -2032,7 +2032,7 @@ impl AstNode for WherePred {
 }
 impl ast::TypeBoundsOwner for WherePred {}
 impl WherePred {
-    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
+    pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -2051,7 +2051,7 @@ impl AstNode for WhereClause {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl WhereClause {
-    pub fn where_kw(&self) -> Option<WhereKw> { support::token(&self.syntax) }
+    pub fn where_kw_token(&self) -> Option<WhereKw> { support::token(&self.syntax) }
     pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -2070,7 +2070,7 @@ impl AstNode for Abi {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl Abi {
-    pub fn string(&self) -> Option<String> { support::token(&self.syntax) }
+    pub fn string_token(&self) -> Option<String> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ExprStmt {
@@ -2090,7 +2090,7 @@ impl AstNode for ExprStmt {
 impl ast::AttrsOwner for ExprStmt {}
 impl ExprStmt {
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
-    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
+    pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LetStmt {
@@ -2110,9 +2110,9 @@ impl AstNode for LetStmt {
 impl ast::AttrsOwner for LetStmt {}
 impl ast::TypeAscriptionOwner for LetStmt {}
 impl LetStmt {
-    pub fn let_kw(&self) -> Option<LetKw> { support::token(&self.syntax) }
+    pub fn let_kw_token(&self) -> Option<LetKw> { support::token(&self.syntax) }
     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
-    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
     pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -2131,9 +2131,9 @@ impl AstNode for Condition {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl Condition {
-    pub fn let_kw(&self) -> Option<LetKw> { support::token(&self.syntax) }
+    pub fn let_kw_token(&self) -> Option<LetKw> { support::token(&self.syntax) }
     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
-    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -2154,10 +2154,10 @@ impl AstNode for Block {
 impl ast::AttrsOwner for Block {}
 impl ast::ModuleItemOwner for Block {}
 impl Block {
-    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) }
     pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
-    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
+    pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ParamList {
@@ -2175,10 +2175,10 @@ impl AstNode for ParamList {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ParamList {
-    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) }
     pub fn self_param(&self) -> Option<SelfParam> { support::child(&self.syntax) }
     pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) }
-    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
+    pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SelfParam {
@@ -2198,9 +2198,9 @@ impl AstNode for SelfParam {
 impl ast::TypeAscriptionOwner for SelfParam {}
 impl ast::AttrsOwner for SelfParam {}
 impl SelfParam {
-    pub fn amp(&self) -> Option<Amp> { support::token(&self.syntax) }
-    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
-    pub fn self_kw(&self) -> Option<SelfKw> { support::token(&self.syntax) }
+    pub fn amp_token(&self) -> Option<Amp> { support::token(&self.syntax) }
+    pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) }
+    pub fn self_kw_token(&self) -> Option<SelfKw> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Param {
@@ -2221,7 +2221,7 @@ impl ast::TypeAscriptionOwner for Param {}
 impl ast::AttrsOwner for Param {}
 impl Param {
     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
-    pub fn dotdotdot(&self) -> Option<Dotdotdot> { support::token(&self.syntax) }
+    pub fn dotdotdot_token(&self) -> Option<Dotdotdot> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct UseItem {
@@ -2241,7 +2241,7 @@ impl AstNode for UseItem {
 impl ast::AttrsOwner for UseItem {}
 impl ast::VisibilityOwner for UseItem {}
 impl UseItem {
-    pub fn use_kw(&self) -> Option<UseKw> { support::token(&self.syntax) }
+    pub fn use_kw_token(&self) -> Option<UseKw> { support::token(&self.syntax) }
     pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -2261,7 +2261,7 @@ impl AstNode for UseTree {
 }
 impl UseTree {
     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
-    pub fn star(&self) -> Option<Star> { support::token(&self.syntax) }
+    pub fn star_token(&self) -> Option<Star> { support::token(&self.syntax) }
     pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) }
     pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) }
 }
@@ -2282,7 +2282,7 @@ impl AstNode for Alias {
 }
 impl ast::NameOwner for Alias {}
 impl Alias {
-    pub fn as_kw(&self) -> Option<AsKw> { support::token(&self.syntax) }
+    pub fn as_kw_token(&self) -> Option<AsKw> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct UseTreeList {
@@ -2300,9 +2300,9 @@ impl AstNode for UseTreeList {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl UseTreeList {
-    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) }
     pub fn use_trees(&self) -> AstChildren<UseTree> { support::children(&self.syntax) }
-    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
+    pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ExternCrateItem {
@@ -2322,8 +2322,8 @@ impl AstNode for ExternCrateItem {
 impl ast::AttrsOwner for ExternCrateItem {}
 impl ast::VisibilityOwner for ExternCrateItem {}
 impl ExternCrateItem {
-    pub fn extern_kw(&self) -> Option<ExternKw> { support::token(&self.syntax) }
-    pub fn crate_kw(&self) -> Option<CrateKw> { support::token(&self.syntax) }
+    pub fn extern_kw_token(&self) -> Option<ExternKw> { support::token(&self.syntax) }
+    pub fn crate_kw_token(&self) -> Option<CrateKw> { support::token(&self.syntax) }
     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
     pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) }
 }
@@ -2343,9 +2343,9 @@ impl AstNode for ArgList {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ArgList {
-    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn l_paren_token(&self) -> Option<LParen> { support::token(&self.syntax) }
     pub fn args(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
-    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
+    pub fn r_paren_token(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Path {
@@ -2382,14 +2382,14 @@ impl AstNode for PathSegment {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl PathSegment {
-    pub fn coloncolon(&self) -> Option<Coloncolon> { support::token(&self.syntax) }
-    pub fn l_angle(&self) -> Option<LAngle> { support::token(&self.syntax) }
+    pub fn coloncolon_token(&self) -> Option<Coloncolon> { support::token(&self.syntax) }
+    pub fn l_angle_token(&self) -> Option<LAngle> { support::token(&self.syntax) }
     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
     pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) }
     pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
     pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
     pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) }
-    pub fn r_angle(&self) -> Option<RAngle> { support::token(&self.syntax) }
+    pub fn r_angle_token(&self) -> Option<RAngle> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TypeArgList {
@@ -2407,14 +2407,14 @@ impl AstNode for TypeArgList {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl TypeArgList {
-    pub fn coloncolon(&self) -> Option<Coloncolon> { support::token(&self.syntax) }
-    pub fn l_angle(&self) -> Option<LAngle> { support::token(&self.syntax) }
+    pub fn coloncolon_token(&self) -> Option<Coloncolon> { support::token(&self.syntax) }
+    pub fn l_angle_token(&self) -> Option<LAngle> { support::token(&self.syntax) }
     pub fn generic_args(&self) -> AstChildren<GenericArg> { support::children(&self.syntax) }
     pub fn type_args(&self) -> AstChildren<TypeArg> { support::children(&self.syntax) }
     pub fn lifetime_args(&self) -> AstChildren<LifetimeArg> { support::children(&self.syntax) }
     pub fn assoc_type_args(&self) -> AstChildren<AssocTypeArg> { support::children(&self.syntax) }
     pub fn const_args(&self) -> AstChildren<ConstArg> { support::children(&self.syntax) }
-    pub fn r_angle(&self) -> Option<RAngle> { support::token(&self.syntax) }
+    pub fn r_angle_token(&self) -> Option<RAngle> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TypeArg {
@@ -2452,7 +2452,7 @@ impl AstNode for AssocTypeArg {
 impl ast::TypeBoundsOwner for AssocTypeArg {}
 impl AssocTypeArg {
     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
-    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -2471,7 +2471,7 @@ impl AstNode for LifetimeArg {
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl LifetimeArg {
-    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
+    pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ConstArg {
@@ -2490,7 +2490,7 @@ impl AstNode for ConstArg {
 }
 impl ConstArg {
     pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
-    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
     pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -2548,9 +2548,9 @@ impl AstNode for ExternItemList {
 impl ast::FnDefOwner for ExternItemList {}
 impl ast::ModuleItemOwner for ExternItemList {}
 impl ExternItemList {
-    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) }
     pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) }
-    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
+    pub fn r_curly_token(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ExternBlock {
@@ -2588,7 +2588,7 @@ impl AstNode for MetaItem {
 }
 impl MetaItem {
     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
-    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
     pub fn attr_input(&self) -> Option<AttrInput> { support::child(&self.syntax) }
     pub fn nested_meta_items(&self) -> AstChildren<MetaItem> { support::children(&self.syntax) }
 }
-- 
cgit v1.2.3


From 2bfb65db93e48d8f9e8ecac0b2ea837c081a4db5 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Thu, 9 Apr 2020 18:40:43 +0200
Subject: Be consistent about token accesors

---
 crates/ra_syntax/src/ast/edit.rs            |   4 +-
 crates/ra_syntax/src/ast/extensions.rs      | 104 +++-------------------------
 crates/ra_syntax/src/ast/generated/nodes.rs |   3 +
 3 files changed, 13 insertions(+), 98 deletions(-)

(limited to 'crates/ra_syntax')

diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs
index 62153f199..069c6ee82 100644
--- a/crates/ra_syntax/src/ast/edit.rs
+++ b/crates/ra_syntax/src/ast/edit.rs
@@ -33,9 +33,9 @@ impl ast::FnDef {
         let mut to_insert: ArrayVec<[SyntaxElement; 2]> = ArrayVec::new();
         let old_body_or_semi: SyntaxElement = if let Some(old_body) = self.body() {
             old_body.syntax().clone().into()
-        } else if let Some(semi) = self.semicolon_token() {
+        } else if let Some(semi) = self.semi_token() {
             to_insert.push(make::tokens::single_space().into());
-            semi.into()
+            semi.syntax.clone().into()
         } else {
             to_insert.push(make::tokens::single_space().into());
             to_insert.push(body.syntax().clone().into());
diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs
index ff3525c84..b50a89864 100644
--- a/crates/ra_syntax/src/ast/extensions.rs
+++ b/crates/ra_syntax/src/ast/extensions.rs
@@ -136,12 +136,6 @@ impl ast::Path {
     }
 }
 
-impl ast::Module {
-    pub fn has_semi(&self) -> bool {
-        self.semi_token().is_some()
-    }
-}
-
 impl ast::UseTreeList {
     pub fn parent_use_tree(&self) -> ast::UseTree {
         self.syntax()
@@ -172,10 +166,6 @@ impl ast::ImplDef {
         let second = types.next();
         (first, second)
     }
-
-    pub fn is_negative(&self) -> bool {
-        self.excl_token().is_some()
-    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -216,31 +206,6 @@ impl ast::EnumVariant {
     }
 }
 
-impl ast::FnDef {
-    pub fn semicolon_token(&self) -> Option<SyntaxToken> {
-        Some(self.semi_token()?.syntax().clone())
-    }
-
-    pub fn is_async(&self) -> bool {
-        self.async_kw_token().is_some()
-    }
-}
-
-impl ast::LetStmt {
-    pub fn has_semi(&self) -> bool {
-        match self.syntax().last_child_or_token() {
-            None => false,
-            Some(node) => node.kind() == T![;],
-        }
-    }
-}
-
-impl ast::ExprStmt {
-    pub fn has_semi(&self) -> bool {
-        self.semi_token().is_some()
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum FieldKind {
     Name(ast::NameRef),
@@ -269,25 +234,6 @@ impl ast::FieldExpr {
     }
 }
 
-impl ast::RefPat {
-    pub fn is_mut(&self) -> bool {
-        self.syntax().children_with_tokens().any(|n| n.kind() == T![mut])
-    }
-}
-
-impl ast::BindPat {
-    pub fn is_mutable(&self) -> bool {
-        self.syntax().children_with_tokens().any(|n| n.kind() == T![mut])
-    }
-
-    pub fn is_ref(&self) -> bool {
-        self.syntax().children_with_tokens().any(|n| n.kind() == T![ref])
-    }
-    pub fn has_at(&self) -> bool {
-        self.syntax().children_with_tokens().any(|it| it.kind() == T![@])
-    }
-}
-
 pub struct SlicePatComponents {
     pub prefix: Vec<ast::Pat>,
     pub slice: Option<ast::Pat>,
@@ -322,18 +268,6 @@ impl ast::SlicePat {
     }
 }
 
-impl ast::PointerType {
-    pub fn is_mut(&self) -> bool {
-        self.syntax().children_with_tokens().any(|n| n.kind() == T![mut])
-    }
-}
-
-impl ast::ReferenceType {
-    pub fn is_mut(&self) -> bool {
-        self.syntax().children_with_tokens().any(|n| n.kind() == T![mut])
-    }
-}
-
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum SelfParamKind {
     /// self
@@ -347,7 +281,7 @@ pub enum SelfParamKind {
 impl ast::SelfParam {
     pub fn kind(&self) -> SelfParamKind {
         if self.amp_token().is_some() {
-            if self.amp_mut_kw().is_some() {
+            if self.amp_mut_kw_token().is_some() {
                 SelfParamKind::MutRef
             } else {
                 SelfParamKind::Ref
@@ -358,7 +292,7 @@ impl ast::SelfParam {
     }
 
     /// the "mut" in "mut self", not the one in "&mut self"
-    pub fn mut_kw(&self) -> Option<ast::MutKw> {
+    pub fn mut_kw_token(&self) -> Option<ast::MutKw> {
         self.syntax()
             .children_with_tokens()
             .filter_map(|it| it.into_token())
@@ -367,7 +301,7 @@ impl ast::SelfParam {
     }
 
     /// the "mut" in "&mut self", not the one in "mut self"
-    pub fn amp_mut_kw(&self) -> Option<ast::MutKw> {
+    pub fn amp_mut_kw_token(&self) -> Option<ast::MutKw> {
         self.syntax()
             .children_with_tokens()
             .filter_map(|it| it.into_token())
@@ -399,11 +333,7 @@ impl ast::TypeBound {
         }
     }
 
-    pub fn has_question_mark(&self) -> bool {
-        self.question().is_some()
-    }
-
-    pub fn const_question(&self) -> Option<ast::Question> {
+    pub fn const_question_token(&self) -> Option<ast::Question> {
         self.syntax()
             .children_with_tokens()
             .filter_map(|it| it.into_token())
@@ -411,7 +341,7 @@ impl ast::TypeBound {
             .find_map(ast::Question::cast)
     }
 
-    pub fn question(&self) -> Option<ast::Question> {
+    pub fn question_token(&self) -> Option<ast::Question> {
         if self.const_kw_token().is_some() {
             self.syntax()
                 .children_with_tokens()
@@ -424,12 +354,6 @@ impl ast::TypeBound {
     }
 }
 
-impl ast::TraitDef {
-    pub fn is_auto(&self) -> bool {
-        self.syntax().children_with_tokens().any(|t| t.kind() == T![auto])
-    }
-}
-
 pub enum VisibilityKind {
     In(ast::Path),
     PubCrate,
@@ -442,28 +366,16 @@ impl ast::Visibility {
     pub fn kind(&self) -> VisibilityKind {
         if let Some(path) = children(self).next() {
             VisibilityKind::In(path)
-        } else if self.is_pub_crate() {
+        } else if self.crate_kw_token().is_some() {
             VisibilityKind::PubCrate
-        } else if self.is_pub_super() {
+        } else if self.super_kw_token().is_some() {
             VisibilityKind::PubSuper
-        } else if self.is_pub_self() {
+        } else if self.self_kw_token().is_some() {
             VisibilityKind::PubSuper
         } else {
             VisibilityKind::Pub
         }
     }
-
-    fn is_pub_crate(&self) -> bool {
-        self.syntax().children_with_tokens().any(|it| it.kind() == T![crate])
-    }
-
-    fn is_pub_super(&self) -> bool {
-        self.syntax().children_with_tokens().any(|it| it.kind() == T![super])
-    }
-
-    fn is_pub_self(&self) -> bool {
-        self.syntax().children_with_tokens().any(|it| it.kind() == T![self])
-    }
 }
 
 impl ast::MacroCall {
diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs
index 0bcb7fe61..bcbfd1129 100644
--- a/crates/ra_syntax/src/ast/generated/nodes.rs
+++ b/crates/ra_syntax/src/ast/generated/nodes.rs
@@ -555,6 +555,7 @@ impl AstNode for PointerType {
 impl PointerType {
     pub fn star_token(&self) -> Option<Star> { support::token(&self.syntax) }
     pub fn const_kw_token(&self) -> Option<ConstKw> { support::token(&self.syntax) }
+    pub fn mut_kw_token(&self) -> Option<MutKw> { support::token(&self.syntax) }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1532,6 +1533,7 @@ impl ast::NameOwner for BindPat {}
 impl BindPat {
     pub fn ref_kw_token(&self) -> Option<RefKw> { support::token(&self.syntax) }
     pub fn mut_kw_token(&self) -> Option<MutKw> { support::token(&self.syntax) }
+    pub fn at_token(&self) -> Option<At> { support::token(&self.syntax) }
     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -2114,6 +2116,7 @@ impl LetStmt {
     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
     pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
     pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Condition {
-- 
cgit v1.2.3