diff --git a/crates/ra_ide_api/src/call_info.rs b/crates/ra_ide_api/src/call_info.rs
index 212448d413b..d5e11652663 100644
--- a/crates/ra_ide_api/src/call_info.rs
+++ b/crates/ra_ide_api/src/call_info.rs
@@ -91,8 +91,8 @@ fn with_node(syntax: &SyntaxNode, offset: TextUnit) -> Option<FnCallNode> {
 
     fn name_ref(&self) -> Option<ast::NameRef> {
         match self {
-            FnCallNode::CallExpr(call_expr) => Some(match call_expr.expr()?.kind() {
-                ast::ExprKind::PathExpr(path_expr) => path_expr.path()?.segment()?.name_ref()?,
+            FnCallNode::CallExpr(call_expr) => Some(match call_expr.expr()? {
+                ast::Expr::PathExpr(path_expr) => path_expr.path()?.segment()?.name_ref()?,
                 _ => return None,
             }),
 
diff --git a/crates/ra_ide_api/src/impls.rs b/crates/ra_ide_api/src/impls.rs
index 638f4cbde27..c5620dd522f 100644
--- a/crates/ra_ide_api/src/impls.rs
+++ b/crates/ra_ide_api/src/impls.rs
@@ -33,13 +33,11 @@ fn impls_for_def(
     node: &ast::NominalDef,
     module: hir::Module,
 ) -> Option<Vec<NavigationTarget>> {
-    let ty = match node.kind() {
-        ast::NominalDefKind::StructDef(def) => {
+    let ty = match node {
+        ast::NominalDef::StructDef(def) => {
             source_binder::struct_from_module(db, module, &def).ty(db)
         }
-        ast::NominalDefKind::EnumDef(def) => {
-            source_binder::enum_from_module(db, module, &def).ty(db)
-        }
+        ast::NominalDef::EnumDef(def) => source_binder::enum_from_module(db, module, &def).ty(db),
     };
 
     let krate = module.krate(db)?;
diff --git a/crates/ra_ide_api/src/inlay_hints.rs b/crates/ra_ide_api/src/inlay_hints.rs
index 0b3c96d26aa..058cd68e291 100644
--- a/crates/ra_ide_api/src/inlay_hints.rs
+++ b/crates/ra_ide_api/src/inlay_hints.rs
@@ -3,7 +3,7 @@
 use ra_syntax::{
     algo::visit::{visitor, Visitor},
     ast::{
-        AstNode, ForExpr, IfExpr, LambdaExpr, LetStmt, MatchArmList, Pat, PatKind, SourceFile,
+        self, AstNode, ForExpr, IfExpr, LambdaExpr, LetStmt, MatchArmList, SourceFile,
         TypeAscriptionOwner, WhileExpr,
     },
     SmolStr, SyntaxKind, SyntaxNode, TextRange,
@@ -88,7 +88,7 @@ fn get_inlay_hints(
 fn get_pat_type_hints(
     db: &RootDatabase,
     analyzer: &SourceAnalyzer,
-    root_pat: Pat,
+    root_pat: ast::Pat,
     skip_root_pat_hint: bool,
 ) -> Vec<InlayHint> {
     let original_pat = &root_pat.clone();
@@ -108,27 +108,27 @@ fn get_pat_type_hints(
         .collect()
 }
 
-fn get_leaf_pats(root_pat: Pat) -> Vec<Pat> {
-    let mut pats_to_process = std::collections::VecDeque::<Pat>::new();
+fn get_leaf_pats(root_pat: ast::Pat) -> Vec<ast::Pat> {
+    let mut pats_to_process = std::collections::VecDeque::<ast::Pat>::new();
     pats_to_process.push_back(root_pat);
 
     let mut leaf_pats = Vec::new();
 
     while let Some(maybe_leaf_pat) = pats_to_process.pop_front() {
-        match maybe_leaf_pat.kind() {
-            PatKind::BindPat(bind_pat) => {
+        match &maybe_leaf_pat {
+            ast::Pat::BindPat(bind_pat) => {
                 if let Some(pat) = bind_pat.pat() {
                     pats_to_process.push_back(pat);
                 } else {
                     leaf_pats.push(maybe_leaf_pat);
                 }
             }
-            PatKind::TuplePat(tuple_pat) => {
+            ast::Pat::TuplePat(tuple_pat) => {
                 for arg_pat in tuple_pat.args() {
                     pats_to_process.push_back(arg_pat);
                 }
             }
-            PatKind::StructPat(struct_pat) => {
+            ast::Pat::StructPat(struct_pat) => {
                 if let Some(pat_list) = struct_pat.field_pat_list() {
                     pats_to_process.extend(
                         pat_list
@@ -139,12 +139,12 @@ fn get_leaf_pats(root_pat: Pat) -> Vec<Pat> {
                                     .filter(|pat| pat.syntax().kind() != SyntaxKind::BIND_PAT)
                             })
                             .chain(pat_list.bind_pats().map(|bind_pat| {
-                                bind_pat.pat().unwrap_or_else(|| Pat::from(bind_pat))
+                                bind_pat.pat().unwrap_or_else(|| ast::Pat::from(bind_pat))
                             })),
                     );
                 }
             }
-            PatKind::TupleStructPat(tuple_struct_pat) => {
+            ast::Pat::TupleStructPat(tuple_struct_pat) => {
                 for arg_pat in tuple_struct_pat.args() {
                     pats_to_process.push_back(arg_pat);
                 }
@@ -158,7 +158,7 @@ fn get_leaf_pats(root_pat: Pat) -> Vec<Pat> {
 fn get_node_displayable_type(
     db: &RootDatabase,
     analyzer: &SourceAnalyzer,
-    node_pat: &Pat,
+    node_pat: &ast::Pat,
 ) -> Option<Ty> {
     analyzer.type_of_pat(db, node_pat).and_then(|resolved_type| {
         if let Ty::Apply(_) = resolved_type {
diff --git a/crates/ra_ide_api/src/references.rs b/crates/ra_ide_api/src/references.rs
index 2118e7ad3e6..342e73fd344 100644
--- a/crates/ra_ide_api/src/references.rs
+++ b/crates/ra_ide_api/src/references.rs
@@ -75,7 +75,7 @@ fn find_binding<'a>(
         let analyzer = hir::SourceAnalyzer::new(db, position.file_id, name_ref.syntax(), None);
         let resolved = analyzer.resolve_local_name(&name_ref)?;
         if let Either::A(ptr) = resolved.ptr() {
-            if let ast::PatKind::BindPat(binding) = ptr.to_node(source_file.syntax()).kind() {
+            if let ast::Pat::BindPat(binding) = ptr.to_node(source_file.syntax()) {
                 return Some((binding, analyzer));
             }
         }
diff --git a/crates/ra_ide_api/src/runnables.rs b/crates/ra_ide_api/src/runnables.rs
index 09c082de9cf..9ea96909e73 100644
--- a/crates/ra_ide_api/src/runnables.rs
+++ b/crates/ra_ide_api/src/runnables.rs
@@ -54,8 +54,8 @@ fn runnable_mod(db: &RootDatabase, file_id: FileId, module: ast::Module) -> Opti
     let has_test_function = module
         .item_list()?
         .items()
-        .filter_map(|it| match it.kind() {
-            ast::ModuleItemKind::FnDef(it) => Some(it),
+        .filter_map(|it| match it {
+            ast::ModuleItem::FnDef(it) => Some(it),
             _ => None,
         })
         .any(|f| f.has_atom_attr("test"));