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: [PATCH] Add _token suffix to token accessors

I think this makes is more clear which things are : AstNode and which
are : AstToken
---
 .../src/handlers/add_explicit_type.rs         |   4 +-
 crates/ra_assists/src/handlers/add_impl.rs    |   2 +-
 crates/ra_assists/src/handlers/add_new.rs     |   2 +-
 .../ra_assists/src/handlers/merge_imports.rs  |   2 +-
 crates/ra_hir_def/src/path/lower.rs           |   2 +-
 crates/ra_hir_def/src/path/lower/lower_use.rs |   2 +-
 crates/ra_hir_ty/src/tests.rs                 |   2 +-
 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 +++++++++---------
 xtask/src/codegen/gen_syntax.rs               |   1 +
 12 files changed, 210 insertions(+), 213 deletions(-)

diff --git a/crates/ra_assists/src/handlers/add_explicit_type.rs b/crates/ra_assists/src/handlers/add_explicit_type.rs
index d86d804b2e..e7dcfb44e2 100644
--- a/crates/ra_assists/src/handlers/add_explicit_type.rs
+++ b/crates/ra_assists/src/handlers/add_explicit_type.rs
@@ -1,6 +1,6 @@
 use hir::HirDisplay;
 use ra_syntax::{
-    ast::{self, AstNode, LetStmt, NameOwner, TypeAscriptionOwner},
+    ast::{self, AstNode, AstToken, LetStmt, NameOwner, TypeAscriptionOwner},
     TextRange,
 };
 
@@ -35,7 +35,7 @@ pub(crate) fn add_explicit_type(ctx: AssistCtx) -> Option<Assist> {
     let name = pat.name()?;
     let name_range = name.syntax().text_range();
     let stmt_range = stmt.syntax().text_range();
-    let eq_range = stmt.eq_token()?.text_range();
+    let eq_range = stmt.eq_token()?.syntax().text_range();
     // Assist should only be applicable if cursor is between 'let' and '='
     let let_range = TextRange::from_to(stmt_range.start(), eq_range.start());
     let cursor_in_range = ctx.frange.range.is_subrange(&let_range);
diff --git a/crates/ra_assists/src/handlers/add_impl.rs b/crates/ra_assists/src/handlers/add_impl.rs
index 72a201b6d2..26dfed2376 100644
--- a/crates/ra_assists/src/handlers/add_impl.rs
+++ b/crates/ra_assists/src/handlers/add_impl.rs
@@ -42,7 +42,7 @@ pub(crate) fn add_impl(ctx: AssistCtx) -> Option<Assist> {
         if let Some(type_params) = type_params {
             let lifetime_params = type_params
                 .lifetime_params()
-                .filter_map(|it| it.lifetime())
+                .filter_map(|it| it.lifetime_token())
                 .map(|it| it.text().clone());
             let type_params =
                 type_params.type_params().filter_map(|it| it.name()).map(|it| it.text().clone());
diff --git a/crates/ra_assists/src/handlers/add_new.rs b/crates/ra_assists/src/handlers/add_new.rs
index c10397249f..30360af942 100644
--- a/crates/ra_assists/src/handlers/add_new.rs
+++ b/crates/ra_assists/src/handlers/add_new.rs
@@ -106,7 +106,7 @@ fn generate_impl_text(strukt: &ast::StructDef, code: &str) -> String {
     if let Some(type_params) = type_params {
         let lifetime_params = type_params
             .lifetime_params()
-            .filter_map(|it| it.lifetime())
+            .filter_map(|it| it.lifetime_token())
             .map(|it| it.text().clone());
         let type_params =
             type_params.type_params().filter_map(|it| it.name()).map(|it| it.text().clone());
diff --git a/crates/ra_assists/src/handlers/merge_imports.rs b/crates/ra_assists/src/handlers/merge_imports.rs
index f8b3ddb4e1..936d50ab49 100644
--- a/crates/ra_assists/src/handlers/merge_imports.rs
+++ b/crates/ra_assists/src/handlers/merge_imports.rs
@@ -82,7 +82,7 @@ fn try_merge_trees(old: &ast::UseTree, new: &ast::UseTree) -> Option<ast::UseTre
             .filter(|it| it.kind() != T!['{'] && it.kind() != T!['}']),
     );
     let use_tree_list = lhs.use_tree_list()?;
-    let pos = InsertPosition::Before(use_tree_list.r_curly()?.syntax().clone().into());
+    let pos = InsertPosition::Before(use_tree_list.r_curly_token()?.syntax().clone().into());
     let use_tree_list = use_tree_list.insert_children(pos, to_insert);
     Some(lhs.with_use_tree_list(use_tree_list))
 }
diff --git a/crates/ra_hir_def/src/path/lower.rs b/crates/ra_hir_def/src/path/lower.rs
index 3c13cb2c78..0f806d6fb5 100644
--- a/crates/ra_hir_def/src/path/lower.rs
+++ b/crates/ra_hir_def/src/path/lower.rs
@@ -28,7 +28,7 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
     loop {
         let segment = path.segment()?;
 
-        if segment.coloncolon().is_some() {
+        if segment.coloncolon_token().is_some() {
             kind = PathKind::Abs;
         }
 
diff --git a/crates/ra_hir_def/src/path/lower/lower_use.rs b/crates/ra_hir_def/src/path/lower/lower_use.rs
index 6ec944228c..5b6854b0f0 100644
--- a/crates/ra_hir_def/src/path/lower/lower_use.rs
+++ b/crates/ra_hir_def/src/path/lower/lower_use.rs
@@ -34,7 +34,7 @@ pub(crate) fn lower_use_tree(
         let alias = tree.alias().map(|a| {
             a.name().map(|it| it.as_name()).map_or(ImportAlias::Underscore, ImportAlias::Alias)
         });
-        let is_glob = tree.star().is_some();
+        let is_glob = tree.star_token().is_some();
         if let Some(ast_path) = tree.path() {
             // Handle self in a path.
             // E.g. `use something::{self, <...>}`
diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs
index ac09662368..f97e0bfebc 100644
--- a/crates/ra_hir_ty/src/tests.rs
+++ b/crates/ra_hir_ty/src/tests.rs
@@ -101,7 +101,7 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
             let node = src_ptr.value.to_node(&src_ptr.file_syntax(&db));
 
             let (range, text) = if let Some(self_param) = ast::SelfParam::cast(node.clone()) {
-                (self_param.self_kw().unwrap().syntax().text_range(), "self".to_string())
+                (self_param.self_kw_token().unwrap().syntax().text_range(), "self".to_string())
             } else {
                 (src_ptr.value.range(), node.text().to_string().replace("\n", " "))
             };
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index a42eec91a9..15a8279f3d 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 d793109953..62153f199b 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 c7df15662e..ff3525c844 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 8b348ad6e1..0bcb7fe61c 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) }
 }
diff --git a/xtask/src/codegen/gen_syntax.rs b/xtask/src/codegen/gen_syntax.rs
index 6657c9fc5f..b5594e3a98 100644
--- a/xtask/src/codegen/gen_syntax.rs
+++ b/xtask/src/codegen/gen_syntax.rs
@@ -208,6 +208,7 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> {
                 FieldSrc::Optional(_) | FieldSrc::Shorthand => {
                     let is_token = token_kinds.contains(&ty.to_string());
                     if is_token {
+                        let method_name = format_ident!("{}_token", method_name);
                         quote! {
                             pub fn #method_name(&self) -> Option<#ty> {
                                 support::token(&self.syntax)