Simpler acessors for keywords

matklad · matklad · commit 30084a56a573 · 2020-04-09T23:42:01.000+02:00
diff --git a/crates/ra_assists/src/handlers/inline_local_variable.rs b/crates/ra_assists/src/handlers/inline_local_variable.rs
@@ -29,7 +29,7 @@ pub(crate) fn inline_local_variable(ctx: AssistCtx) -> Option<Assist> {
         ast::Pat::BindPat(pat) => pat,
         _ => return None,
     };
-    if bind_pat.mut_kw_token().is_some() {
+    if bind_pat.mut_token().is_some() {
         tested_by!(test_not_inline_mut_variable);
         return None;
     }
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
@@ -372,7 +372,7 @@ impl ExprCollector<'_> {
             }
             ast::Expr::RefExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
-                let mutability = Mutability::from_mutable(e.mut_kw_token().is_some());
+                let mutability = Mutability::from_mutable(e.mut_token().is_some());
                 self.alloc_expr(Expr::Ref { expr, mutability }, syntax_ptr)
             }
             ast::Expr::PrefixExpr(e) => {
@@ -587,10 +587,8 @@ impl ExprCollector<'_> {
         let pattern = match &pat {
             ast::Pat::BindPat(bp) => {
                 let name = bp.name().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
-                let annotation = BindingAnnotation::new(
-                    bp.mut_kw_token().is_some(),
-                    bp.ref_kw_token().is_some(),
-                );
+                let annotation =
+                    BindingAnnotation::new(bp.mut_token().is_some(), bp.ref_token().is_some());
                 let subpat = bp.pat().map(|subpat| self.collect_pat(subpat));
                 if annotation == BindingAnnotation::Unannotated && subpat.is_none() {
                     // This could also be a single-segment path pattern. To
@@ -631,7 +629,7 @@ impl ExprCollector<'_> {
             }
             ast::Pat::RefPat(p) => {
                 let pat = self.collect_pat_opt(p.pat());
-                let mutability = Mutability::from_mutable(p.mut_kw_token().is_some());
+                let mutability = Mutability::from_mutable(p.mut_token().is_some());
                 Pat::Ref { pat, mutability }
             }
             ast::Pat::PathPat(p) => {
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
@@ -74,7 +74,7 @@ impl FunctionData {
             TypeRef::unit()
         };
 
-        let ret_type = if src.value.async_kw_token().is_some() {
+        let ret_type = if src.value.async_token().is_some() {
             let future_impl = desugar_future_path(ret_type);
             let ty_bound = TypeBound::Path(future_impl);
             TypeRef::ImplTrait(vec![ty_bound])
@@ -135,7 +135,7 @@ impl TraitData {
     pub(crate) fn trait_data_query(db: &dyn DefDatabase, tr: TraitId) -> Arc<TraitData> {
         let src = tr.lookup(db).source(db);
         let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
-        let auto = src.value.auto_kw_token().is_some();
+        let auto = src.value.auto_token().is_some();
         let ast_id_map = db.ast_id_map(src.file_id);
 
         let container = AssocContainerId::TraitId(tr);
diff --git a/crates/ra_hir_def/src/type_ref.rs b/crates/ra_hir_def/src/type_ref.rs
@@ -77,7 +77,7 @@ impl TypeRef {
             }
             ast::TypeRef::PointerType(inner) => {
                 let inner_ty = TypeRef::from_ast_opt(inner.type_ref());
-                let mutability = Mutability::from_mutable(inner.mut_kw_token().is_some());
+                let mutability = Mutability::from_mutable(inner.mut_token().is_some());
                 TypeRef::RawPtr(Box::new(inner_ty), mutability)
             }
             ast::TypeRef::ArrayType(inner) => {
@@ -88,7 +88,7 @@ impl TypeRef {
             }
             ast::TypeRef::ReferenceType(inner) => {
                 let inner_ty = TypeRef::from_ast_opt(inner.type_ref());
-                let mutability = Mutability::from_mutable(inner.mut_kw_token().is_some());
+                let mutability = Mutability::from_mutable(inner.mut_token().is_some());
                 TypeRef::Reference(Box::new(inner_ty), mutability)
             }
             ast::TypeRef::PlaceholderType(_inner) => TypeRef::Placeholder,
diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs
@@ -23,7 +23,7 @@ use insta::assert_snapshot;
 use ra_db::{fixture::WithFixture, salsa::Database, FilePosition, SourceDatabase};
 use ra_syntax::{
     algo,
-    ast::{self, AstNode, AstToken},
+    ast::{self, AstNode},
 };
 use stdx::format_to;
 
@@ -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_token().unwrap().syntax().text_range(), "self".to_string())
+                (self_param.self_token().unwrap().text_range(), "self".to_string())
             } else {
                 (src_ptr.value.range(), node.text().to_string().replace("\n", " "))
             };
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
@@ -191,8 +191,8 @@ impl<'a> CompletionContext<'a> {
             if let Some(bind_pat) = name.syntax().ancestors().find_map(ast::BindPat::cast) {
                 self.is_pat_binding_or_const = true;
                 if bind_pat.at_token().is_some()
-                    || bind_pat.ref_kw_token().is_some()
-                    || bind_pat.mut_kw_token().is_some()
+                    || bind_pat.ref_token().is_some()
+                    || bind_pat.mut_token().is_some()
                 {
                     self.is_pat_binding_or_const = false;
                 }
diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs
@@ -152,7 +152,7 @@ fn decl_access(def: &Definition, syntax: &SyntaxNode, range: TextRange) -> Optio
     if stmt.initializer().is_some() {
         let pat = stmt.pat()?;
         if let ast::Pat::BindPat(it) = pat {
-            if it.mut_kw_token().is_some() {
+            if it.mut_token().is_some() {
                 return Some(ReferenceAccess::Write);
             }
         }
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
@@ -80,7 +80,7 @@ impl<N: AstNode> Iterator for AstChildren<N> {
 }
 
 mod support {
-    use super::{AstChildren, AstNode, AstToken, SyntaxNode};
+    use super::{AstChildren, AstNode, AstToken, SyntaxKind, SyntaxNode, SyntaxToken};
 
     pub(super) fn child<N: AstNode>(parent: &SyntaxNode) -> Option<N> {
         parent.children().find_map(N::cast)
@@ -93,6 +93,10 @@ mod support {
     pub(super) fn token<T: AstToken>(parent: &SyntaxNode) -> Option<T> {
         parent.children_with_tokens().filter_map(|it| it.into_token()).find_map(T::cast)
     }
+
+    pub(super) fn token2(parent: &SyntaxNode, kind: SyntaxKind) -> Option<SyntaxToken> {
+        parent.children_with_tokens().filter_map(|it| it.into_token()).find(|it| it.kind() == kind)
+    }
 }
 
 #[test]
diff --git a/crates/ra_syntax/src/ast/expr_extensions.rs b/crates/ra_syntax/src/ast/expr_extensions.rs
@@ -48,12 +48,6 @@ impl ast::IfExpr {
     }
 }
 
-impl ast::RefExpr {
-    pub fn raw_token(&self) -> Option<SyntaxToken> {
-        None // FIXME: implement &raw
-    }
-}
-
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum PrefixOp {
     /// The `*` operator for dereferencing
diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs
@@ -279,7 +279,7 @@ pub enum SelfParamKind {
 impl ast::SelfParam {
     pub fn kind(&self) -> SelfParamKind {
         if self.amp_token().is_some() {
-            if self.amp_mut_kw_token().is_some() {
+            if self.amp_mut_token().is_some() {
                 SelfParamKind::MutRef
             } else {
                 SelfParamKind::Ref
@@ -290,21 +290,21 @@ impl ast::SelfParam {
     }
 
     /// the "mut" in "mut self", not the one in "&mut self"
-    pub fn mut_kw_token(&self) -> Option<ast::MutKw> {
+    pub fn mut_token(&self) -> Option<SyntaxToken> {
         self.syntax()
             .children_with_tokens()
             .filter_map(|it| it.into_token())
             .take_while(|it| it.kind() != T![&])
-            .find_map(ast::MutKw::cast)
+            .find(|it| it.kind() == T![mut])
     }
 
     /// the "mut" in "&mut self", not the one in "mut self"
-    pub fn amp_mut_kw_token(&self) -> Option<ast::MutKw> {
+    pub fn amp_mut_token(&self) -> Option<SyntaxToken> {
         self.syntax()
             .children_with_tokens()
             .filter_map(|it| it.into_token())
             .skip_while(|it| it.kind() != T![&])
-            .find_map(ast::MutKw::cast)
+            .find(|it| it.kind() == T![mut])
     }
 }
 
@@ -340,7 +340,7 @@ impl ast::TypeBound {
     }
 
     pub fn question_token(&self) -> Option<ast::Question> {
-        if self.const_kw_token().is_some() {
+        if self.const_token().is_some() {
             self.syntax()
                 .children_with_tokens()
                 .filter_map(|it| it.into_token())
@@ -364,11 +364,11 @@ impl ast::Visibility {
     pub fn kind(&self) -> VisibilityKind {
         if let Some(path) = support::children(self.syntax()).next() {
             VisibilityKind::In(path)
-        } else if self.crate_kw_token().is_some() {
+        } else if self.crate_token().is_some() {
             VisibilityKind::PubCrate
-        } else if self.super_kw_token().is_some() {
+        } else if self.super_token().is_some() {
             VisibilityKind::PubSuper
-        } else if self.self_kw_token().is_some() {
+        } else if self.self_token().is_some() {
             VisibilityKind::PubSuper
         } else {
             VisibilityKind::Pub
diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs
diff --git a/crates/ra_syntax/src/ast/generated/tokens.rs b/crates/ra_syntax/src/ast/generated/tokens.rs
diff --git a/xtask/src/ast_src.rs b/xtask/src/ast_src.rs
diff --git a/xtask/src/codegen/gen_syntax.rs b/xtask/src/codegen/gen_syntax.rs

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ pub(crate) fn inline_local_variable(ctx: AssistCtx) -> Option<Assist> {`
`29`	`29`	`ast::Pat::BindPat(pat) => pat,`
`30`	`30`	`_ => return None,`
`31`	`31`	`};`
`32`		`- if bind_pat.mut_kw_token().is_some() {`
	`32`	`+ if bind_pat.mut_token().is_some() {`
`33`	`33`	`tested_by!(test_not_inline_mut_variable);`
`34`	`34`	`return None;`
`35`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ impl TypeRef {`
`77`	`77`	`}`
`78`	`78`	`ast::TypeRef::PointerType(inner) => {`
`79`	`79`	`let inner_ty = TypeRef::from_ast_opt(inner.type_ref());`
`80`		`- let mutability = Mutability::from_mutable(inner.mut_kw_token().is_some());`
	`80`	`+ let mutability = Mutability::from_mutable(inner.mut_token().is_some());`
`81`	`81`	`TypeRef::RawPtr(Box::new(inner_ty), mutability)`
`82`	`82`	`}`
`83`	`83`	`ast::TypeRef::ArrayType(inner) => {`
`@@ -88,7 +88,7 @@ impl TypeRef {`
`88`	`88`	`}`
`89`	`89`	`ast::TypeRef::ReferenceType(inner) => {`
`90`	`90`	`let inner_ty = TypeRef::from_ast_opt(inner.type_ref());`
`91`		`- let mutability = Mutability::from_mutable(inner.mut_kw_token().is_some());`
	`91`	`+ let mutability = Mutability::from_mutable(inner.mut_token().is_some());`
`92`	`92`	`TypeRef::Reference(Box::new(inner_ty), mutability)`
`93`	`93`	`}`
`94`	`94`	`ast::TypeRef::PlaceholderType(_inner) => TypeRef::Placeholder,`
Original file line number	Diff line number	Diff line change
`@@ -191,8 +191,8 @@ impl<'a> CompletionContext<'a> {`
`191`	`191`	`if let Some(bind_pat) = name.syntax().ancestors().find_map(ast::BindPat::cast) {`
`192`	`192`	`self.is_pat_binding_or_const = true;`
`193`	`193`	`if bind_pat.at_token().is_some()`
`194`		`- \|\| bind_pat.ref_kw_token().is_some()`
`195`		`- \|\| bind_pat.mut_kw_token().is_some()`
	`194`	`+ \|\| bind_pat.ref_token().is_some()`
	`195`	`+ \|\| bind_pat.mut_token().is_some()`
`196`	`196`	`{`
`197`	`197`	`self.is_pat_binding_or_const = false;`
`198`	`198`	`}`
Original file line number	Diff line number	Diff line change
`@@ -152,7 +152,7 @@ fn decl_access(def: &Definition, syntax: &SyntaxNode, range: TextRange) -> Optio`
`152`	`152`	`if stmt.initializer().is_some() {`
`153`	`153`	`let pat = stmt.pat()?;`
`154`	`154`	`if let ast::Pat::BindPat(it) = pat {`
`155`		`- if it.mut_kw_token().is_some() {`
	`155`	`+ if it.mut_token().is_some() {`
`156`	`156`	`return Some(ReferenceAccess::Write);`
`157`	`157`	`}`
`158`	`158`	`}`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ impl<N: AstNode> Iterator for AstChildren<N> {`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`mod support {`
`83`		`- use super::{AstChildren, AstNode, AstToken, SyntaxNode};`
	`83`	`+ use super::{AstChildren, AstNode, AstToken, SyntaxKind, SyntaxNode, SyntaxToken};`
`84`	`84`
`85`	`85`	`pub(super) fn child<N: AstNode>(parent: &SyntaxNode) -> Option<N> {`
`86`	`86`	`parent.children().find_map(N::cast)`
`@@ -93,6 +93,10 @@ mod support {`
`93`	`93`	`pub(super) fn token<T: AstToken>(parent: &SyntaxNode) -> Option<T> {`
`94`	`94`	`parent.children_with_tokens().filter_map(\|it\| it.into_token()).find_map(T::cast)`
`95`	`95`	`}`
	`96`	`+`
	`97`	`+ pub(super) fn token2(parent: &SyntaxNode, kind: SyntaxKind) -> Option<SyntaxToken> {`
	`98`	`+ parent.children_with_tokens().filter_map(\|it\| it.into_token()).find(\|it\| it.kind() == kind)`
	`99`	`+ }`
`96`	`100`	`}`
`97`	`101`
`98`	`102`	`#[test]`
Original file line number	Diff line number	Diff line change
`@@ -48,12 +48,6 @@ impl ast::IfExpr {`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`
`51`		`-impl ast::RefExpr {`
`52`		`- pub fn raw_token(&self) -> Option<SyntaxToken> {`
`53`		`- None // FIXME: implement &raw`
`54`		`- }`
`55`		`-}`
`56`		`-`
`57`	`51`	`#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]`
`58`	`52`	`pub enum PrefixOp {`
`59`	`53`	/// The `*` operator for dereferencing