Merge #1700

1700: remove  ast::*Kind enums r=matklad a=matklad

bors r+

Co-authored-by: Aleksey Kladov <[email protected]>

5 files changed, 45 insertions, 45 deletions

diff --git a/crates/ra_assists/src/add_explicit_type.rs b/crates/ra_assists/src/add_explicit_type.rs
index 88970929f..78f0f7f28 100644
--- a/crates/ra_assists/src/add_explicit_type.rs
+++ b/crates/ra_assists/src/add_explicit_type.rs
@@ -1,6 +1,6 @@
 use hir::{db::HirDatabase, HirDisplay, Ty};
 use ra_syntax::{
-    ast::{AstNode, LetStmt, NameOwner, PatKind},
+    ast::{self, AstNode, LetStmt, NameOwner},
     T,
 };
 
@@ -12,8 +12,8 @@ pub(crate) fn add_explicit_type(mut ctx: AssistCtx<impl HirDatabase>) -> Option<
     let expr = stmt.initializer()?;
     let pat = stmt.pat()?;
     // Must be a binding
-    let pat = match pat.kind() {
-        PatKind::BindPat(bind_pat) => bind_pat,
+    let pat = match pat {
+        ast::Pat::BindPat(bind_pat) => bind_pat,
         _ => return None,
     };
     let pat_range = pat.syntax().text_range();
diff --git a/crates/ra_assists/src/add_missing_impl_members.rs b/crates/ra_assists/src/add_missing_impl_members.rs
index 995e44d5e..31c7d4e80 100644
--- a/crates/ra_assists/src/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/add_missing_impl_members.rs
@@ -5,7 +5,7 @@ use crate::{
 
 use hir::{db::HirDatabase, HasSource};
 use ra_db::FilePosition;
-use ra_syntax::ast::{self, AstNode, ImplItemKind, NameOwner};
+use ra_syntax::ast::{self, AstNode, NameOwner};
 use ra_syntax::SmolStr;
 
 #[derive(PartialEq)]
@@ -49,11 +49,11 @@ fn add_missing_impl_members_inner(
         resolve_target_trait_def(ctx.db, &analyzer, &impl_node)?
     };
 
-    let def_name = |kind| -> Option<SmolStr> {
-        match kind {
-            ast::ImplItemKind::FnDef(def) => def.name(),
-            ast::ImplItemKind::TypeAliasDef(def) => def.name(),
-            ast::ImplItemKind::ConstDef(def) => def.name(),
+    let def_name = |item: &ast::ImplItem| -> Option<SmolStr> {
+        match item {
+            ast::ImplItem::FnDef(def) => def.name(),
+            ast::ImplItem::TypeAliasDef(def) => def.name(),
+            ast::ImplItem::ConstDef(def) => def.name(),
         }
         .map(|it| it.text().clone())
     };
@@ -62,15 +62,15 @@ fn add_missing_impl_members_inner(
     let impl_items = impl_item_list.impl_items().collect::<Vec<_>>();
 
     let missing_items: Vec<_> = trait_items
-        .filter(|t| def_name(t.kind()).is_some())
-        .filter(|t| match t.kind() {
-            ImplItemKind::FnDef(def) => match mode {
+        .filter(|t| def_name(t).is_some())
+        .filter(|t| match t {
+            ast::ImplItem::FnDef(def) => match mode {
                 AddMissingImplMembersMode::DefaultMethodsOnly => def.body().is_some(),
                 AddMissingImplMembersMode::NoDefaultMethods => def.body().is_none(),
             },
             _ => mode == AddMissingImplMembersMode::NoDefaultMethods,
         })
-        .filter(|t| impl_items.iter().all(|i| def_name(i.kind()) != def_name(t.kind())))
+        .filter(|t| impl_items.iter().all(|i| def_name(i) != def_name(t)))
         .collect();
     if missing_items.is_empty() {
         return None;
@@ -78,8 +78,8 @@ fn add_missing_impl_members_inner(
 
     ctx.add_action(AssistId(assist_id), label, |edit| {
         let n_existing_items = impl_item_list.impl_items().count();
-        let items = missing_items.into_iter().map(|it| match it.kind() {
-            ImplItemKind::FnDef(def) => strip_docstring(add_body(def).into()),
+        let items = missing_items.into_iter().map(|it| match it {
+            ast::ImplItem::FnDef(def) => strip_docstring(add_body(def).into()),
             _ => strip_docstring(it),
         });
         let mut ast_editor = AstEditor::new(impl_item_list);
diff --git a/crates/ra_assists/src/fill_match_arms.rs b/crates/ra_assists/src/fill_match_arms.rs
index 939429892..85ff5c052 100644
--- a/crates/ra_assists/src/fill_match_arms.rs
+++ b/crates/ra_assists/src/fill_match_arms.rs
@@ -7,12 +7,12 @@ use ra_syntax::ast::{self, AstNode};
 use crate::{Assist, AssistCtx, AssistId};
 
 fn is_trivial_arm(arm: &ast::MatchArm) -> bool {
-    fn single_pattern(arm: &ast::MatchArm) -> Option<ast::PatKind> {
+    fn single_pattern(arm: &ast::MatchArm) -> Option<ast::Pat> {
         let (pat,) = arm.pats().collect_tuple()?;
-        Some(pat.kind())
+        Some(pat)
     }
     match single_pattern(arm) {
-        Some(ast::PatKind::PlaceholderPat(..)) => true,
+        Some(ast::Pat::PlaceholderPat(..)) => true,
         _ => false,
     }
 }
diff --git a/crates/ra_assists/src/inline_local_variable.rs b/crates/ra_assists/src/inline_local_variable.rs
index 82c4d54b0..eedb29199 100644
--- a/crates/ra_assists/src/inline_local_variable.rs
+++ b/crates/ra_assists/src/inline_local_variable.rs
@@ -1,6 +1,6 @@
 use hir::db::HirDatabase;
 use ra_syntax::{
-    ast::{self, AstNode, AstToken, ExprKind, PatKind},
+    ast::{self, AstNode, AstToken},
     TextRange,
 };
 
@@ -9,8 +9,8 @@ use crate::{Assist, AssistCtx, AssistId};
 
 pub(crate) fn inline_local_varialbe(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
     let let_stmt = ctx.node_at_offset::<ast::LetStmt>()?;
-    let bind_pat = match let_stmt.pat()?.kind() {
-        PatKind::BindPat(pat) => pat,
+    let bind_pat = match let_stmt.pat()? {
+        ast::Pat::BindPat(pat) => pat,
         _ => return None,
     };
     if bind_pat.is_mutable() {
@@ -48,28 +48,28 @@ pub(crate) fn inline_local_varialbe(mut ctx: AssistCtx<impl HirDatabase>) -> Opt
             }
         };
 
-        wrap_in_parens[i] = match (initializer_expr.kind(), usage_parent.kind()) {
-            (ExprKind::CallExpr(_), _)
-            | (ExprKind::IndexExpr(_), _)
-            | (ExprKind::MethodCallExpr(_), _)
-            | (ExprKind::FieldExpr(_), _)
-            | (ExprKind::TryExpr(_), _)
-            | (ExprKind::RefExpr(_), _)
-            | (ExprKind::Literal(_), _)
-            | (ExprKind::TupleExpr(_), _)
-            | (ExprKind::ArrayExpr(_), _)
-            | (ExprKind::ParenExpr(_), _)
-            | (ExprKind::PathExpr(_), _)
-            | (ExprKind::BlockExpr(_), _)
-            | (_, ExprKind::CallExpr(_))
-            | (_, ExprKind::TupleExpr(_))
-            | (_, ExprKind::ArrayExpr(_))
-            | (_, ExprKind::ParenExpr(_))
-            | (_, ExprKind::ForExpr(_))
-            | (_, ExprKind::WhileExpr(_))
-            | (_, ExprKind::BreakExpr(_))
-            | (_, ExprKind::ReturnExpr(_))
-            | (_, ExprKind::MatchExpr(_)) => false,
+        wrap_in_parens[i] = match (&initializer_expr, usage_parent) {
+            (ast::Expr::CallExpr(_), _)
+            | (ast::Expr::IndexExpr(_), _)
+            | (ast::Expr::MethodCallExpr(_), _)
+            | (ast::Expr::FieldExpr(_), _)
+            | (ast::Expr::TryExpr(_), _)
+            | (ast::Expr::RefExpr(_), _)
+            | (ast::Expr::Literal(_), _)
+            | (ast::Expr::TupleExpr(_), _)
+            | (ast::Expr::ArrayExpr(_), _)
+            | (ast::Expr::ParenExpr(_), _)
+            | (ast::Expr::PathExpr(_), _)
+            | (ast::Expr::BlockExpr(_), _)
+            | (_, ast::Expr::CallExpr(_))
+            | (_, ast::Expr::TupleExpr(_))
+            | (_, ast::Expr::ArrayExpr(_))
+            | (_, ast::Expr::ParenExpr(_))
+            | (_, ast::Expr::ForExpr(_))
+            | (_, ast::Expr::WhileExpr(_))
+            | (_, ast::Expr::BreakExpr(_))
+            | (_, ast::Expr::ReturnExpr(_))
+            | (_, ast::Expr::MatchExpr(_)) => false,
             _ => true,
         };
     }
diff --git a/crates/ra_assists/src/merge_match_arms.rs b/crates/ra_assists/src/merge_match_arms.rs
index bc5f6f17c..225a48d3a 100644
--- a/crates/ra_assists/src/merge_match_arms.rs
+++ b/crates/ra_assists/src/merge_match_arms.rs
@@ -30,8 +30,8 @@ pub(crate) fn merge_match_arms(mut ctx: AssistCtx<impl HirDatabase>) -> Option<A
 
     ctx.add_action(AssistId("merge_match_arms"), "merge match arms", |edit| {
         fn contains_placeholder(a: &MatchArm) -> bool {
-            a.pats().any(|x| match x.kind() {
-                ra_syntax::ast::PatKind::PlaceholderPat(..) => true,
+            a.pats().any(|x| match x {
+                ra_syntax::ast::Pat::PlaceholderPat(..) => true,
                 _ => false,
             })
         }