diff --git a/crates/ra_assists/src/add_explicit_type.rs b/crates/ra_assists/src/add_explicit_type.rs
index 88970929ffc1..78f0f7f28a54 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 995e44d5eedf..31c7d4e804ee 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 939429892661..85ff5c052a99 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 82c4d54b0c6f..eedb2919943b 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 bc5f6f17c602..225a48d3adc6 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,
             })
         }
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index a16561d11434..328d635d4580 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -602,8 +602,8 @@ where
 
     fn collect_expr(&mut self, expr: ast::Expr) -> ExprId {
         let syntax_ptr = SyntaxNodePtr::new(expr.syntax());
-        match expr.kind() {
-            ast::ExprKind::IfExpr(e) => {
+        match expr {
+            ast::Expr::IfExpr(e) => {
                 let then_branch = self.collect_block_opt(e.then_branch());
 
                 let else_branch = e.else_branch().map(|b| match b {
@@ -639,16 +639,16 @@ where
 
                 self.alloc_expr(Expr::If { condition, then_branch, else_branch }, syntax_ptr)
             }
-            ast::ExprKind::TryBlockExpr(e) => {
+            ast::Expr::TryBlockExpr(e) => {
                 let body = self.collect_block_opt(e.try_body());
                 self.alloc_expr(Expr::TryBlock { body }, syntax_ptr)
             }
-            ast::ExprKind::BlockExpr(e) => self.collect_block_opt(e.block()),
-            ast::ExprKind::LoopExpr(e) => {
+            ast::Expr::BlockExpr(e) => self.collect_block_opt(e.block()),
+            ast::Expr::LoopExpr(e) => {
                 let body = self.collect_block_opt(e.loop_body());
                 self.alloc_expr(Expr::Loop { body }, syntax_ptr)
             }
-            ast::ExprKind::WhileExpr(e) => {
+            ast::Expr::WhileExpr(e) => {
                 let body = self.collect_block_opt(e.loop_body());
 
                 let condition = match e.condition() {
@@ -675,13 +675,13 @@ where
 
                 self.alloc_expr(Expr::While { condition, body }, syntax_ptr)
             }
-            ast::ExprKind::ForExpr(e) => {
+            ast::Expr::ForExpr(e) => {
                 let iterable = self.collect_expr_opt(e.iterable());
                 let pat = self.collect_pat_opt(e.pat());
                 let body = self.collect_block_opt(e.loop_body());
                 self.alloc_expr(Expr::For { iterable, pat, body }, syntax_ptr)
             }
-            ast::ExprKind::CallExpr(e) => {
+            ast::Expr::CallExpr(e) => {
                 let callee = self.collect_expr_opt(e.expr());
                 let args = if let Some(arg_list) = e.arg_list() {
                     arg_list.args().map(|e| self.collect_expr(e)).collect()
@@ -690,7 +690,7 @@ where
                 };
                 self.alloc_expr(Expr::Call { callee, args }, syntax_ptr)
             }
-            ast::ExprKind::MethodCallExpr(e) => {
+            ast::Expr::MethodCallExpr(e) => {
                 let receiver = self.collect_expr_opt(e.expr());
                 let args = if let Some(arg_list) = e.arg_list() {
                     arg_list.args().map(|e| self.collect_expr(e)).collect()
@@ -704,7 +704,7 @@ where
                     syntax_ptr,
                 )
             }
-            ast::ExprKind::MatchExpr(e) => {
+            ast::Expr::MatchExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
                 let arms = if let Some(match_arm_list) = e.match_arm_list() {
                     match_arm_list
@@ -723,30 +723,30 @@ where
                 };
                 self.alloc_expr(Expr::Match { expr, arms }, syntax_ptr)
             }
-            ast::ExprKind::PathExpr(e) => {
+            ast::Expr::PathExpr(e) => {
                 let path =
                     e.path().and_then(Path::from_ast).map(Expr::Path).unwrap_or(Expr::Missing);
                 self.alloc_expr(path, syntax_ptr)
             }
-            ast::ExprKind::ContinueExpr(_e) => {
+            ast::Expr::ContinueExpr(_e) => {
                 // FIXME: labels
                 self.alloc_expr(Expr::Continue, syntax_ptr)
             }
-            ast::ExprKind::BreakExpr(e) => {
+            ast::Expr::BreakExpr(e) => {
                 let expr = e.expr().map(|e| self.collect_expr(e));
                 self.alloc_expr(Expr::Break { expr }, syntax_ptr)
             }
-            ast::ExprKind::ParenExpr(e) => {
+            ast::Expr::ParenExpr(e) => {
                 let inner = self.collect_expr_opt(e.expr());
                 // make the paren expr point to the inner expression as well
                 self.source_map.expr_map.insert(syntax_ptr, inner);
                 inner
             }
-            ast::ExprKind::ReturnExpr(e) => {
+            ast::Expr::ReturnExpr(e) => {
                 let expr = e.expr().map(|e| self.collect_expr(e));
                 self.alloc_expr(Expr::Return { expr }, syntax_ptr)
             }
-            ast::ExprKind::StructLit(e) => {
+            ast::Expr::StructLit(e) => {
                 let path = e.path().and_then(Path::from_ast);
                 let mut field_ptrs = Vec::new();
                 let struct_lit = if let Some(nfl) = e.named_field_list() {
@@ -787,7 +787,7 @@ where
                 }
                 res
             }
-            ast::ExprKind::FieldExpr(e) => {
+            ast::Expr::FieldExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
                 let name = match e.field_access() {
                     Some(kind) => kind.as_name(),
@@ -795,25 +795,25 @@ where
                 };
                 self.alloc_expr(Expr::Field { expr, name }, syntax_ptr)
             }
-            ast::ExprKind::AwaitExpr(e) => {
+            ast::Expr::AwaitExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
                 self.alloc_expr(Expr::Await { expr }, syntax_ptr)
             }
-            ast::ExprKind::TryExpr(e) => {
+            ast::Expr::TryExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
                 self.alloc_expr(Expr::Try { expr }, syntax_ptr)
             }
-            ast::ExprKind::CastExpr(e) => {
+            ast::Expr::CastExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
                 let type_ref = TypeRef::from_ast_opt(e.type_ref());
                 self.alloc_expr(Expr::Cast { expr, type_ref }, syntax_ptr)
             }
-            ast::ExprKind::RefExpr(e) => {
+            ast::Expr::RefExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
                 let mutability = Mutability::from_mutable(e.is_mut());
                 self.alloc_expr(Expr::Ref { expr, mutability }, syntax_ptr)
             }
-            ast::ExprKind::PrefixExpr(e) => {
+            ast::Expr::PrefixExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
                 if let Some(op) = e.op_kind() {
                     self.alloc_expr(Expr::UnaryOp { expr, op }, syntax_ptr)
@@ -821,7 +821,7 @@ where
                     self.alloc_expr(Expr::Missing, syntax_ptr)
                 }
             }
-            ast::ExprKind::LambdaExpr(e) => {
+            ast::Expr::LambdaExpr(e) => {
                 let mut args = Vec::new();
                 let mut arg_types = Vec::new();
                 if let Some(pl) = e.param_list() {
@@ -835,18 +835,18 @@ where
                 let body = self.collect_expr_opt(e.body());
                 self.alloc_expr(Expr::Lambda { args, arg_types, body }, syntax_ptr)
             }
-            ast::ExprKind::BinExpr(e) => {
+            ast::Expr::BinExpr(e) => {
                 let lhs = self.collect_expr_opt(e.lhs());
                 let rhs = self.collect_expr_opt(e.rhs());
                 let op = e.op_kind().map(BinaryOp::from);
                 self.alloc_expr(Expr::BinaryOp { lhs, rhs, op }, syntax_ptr)
             }
-            ast::ExprKind::TupleExpr(e) => {
+            ast::Expr::TupleExpr(e) => {
                 let exprs = e.exprs().map(|expr| self.collect_expr(expr)).collect();
                 self.alloc_expr(Expr::Tuple { exprs }, syntax_ptr)
             }
 
-            ast::ExprKind::ArrayExpr(e) => {
+            ast::Expr::ArrayExpr(e) => {
                 let kind = e.kind();
 
                 match kind {
@@ -865,7 +865,7 @@ where
                 }
             }
 
-            ast::ExprKind::Literal(e) => {
+            ast::Expr::Literal(e) => {
                 let lit = match e.kind() {
                     LiteralKind::IntNumber { suffix } => {
                         let known_name = suffix
@@ -895,16 +895,16 @@ where
                 };
                 self.alloc_expr(Expr::Literal(lit), syntax_ptr)
             }
-            ast::ExprKind::IndexExpr(e) => {
+            ast::Expr::IndexExpr(e) => {
                 let base = self.collect_expr_opt(e.base());
                 let index = self.collect_expr_opt(e.index());
                 self.alloc_expr(Expr::Index { base, index }, syntax_ptr)
             }
 
             // FIXME implement HIR for these:
-            ast::ExprKind::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
-            ast::ExprKind::RangeExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
-            ast::ExprKind::MacroCall(e) => {
+            ast::Expr::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
+            ast::Expr::RangeExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
+            ast::Expr::MacroCall(e) => {
                 let ast_id = self
                     .db
                     .ast_id_map(self.current_file_id)
@@ -945,16 +945,14 @@ where
     fn collect_block(&mut self, block: ast::Block) -> ExprId {
         let statements = block
             .statements()
-            .map(|s| match s.kind() {
-                ast::StmtKind::LetStmt(stmt) => {
+            .map(|s| match s {
+                ast::Stmt::LetStmt(stmt) => {
                     let pat = self.collect_pat_opt(stmt.pat());
                     let type_ref = stmt.ascribed_type().map(TypeRef::from_ast);
                     let initializer = stmt.initializer().map(|e| self.collect_expr(e));
                     Statement::Let { pat, type_ref, initializer }
                 }
-                ast::StmtKind::ExprStmt(stmt) => {
-                    Statement::Expr(self.collect_expr_opt(stmt.expr()))
-                }
+                ast::Stmt::ExprStmt(stmt) => Statement::Expr(self.collect_expr_opt(stmt.expr())),
             })
             .collect();
         let tail = block.expr().map(|e| self.collect_expr(e));
@@ -970,33 +968,33 @@ where
     }
 
     fn collect_pat(&mut self, pat: ast::Pat) -> PatId {
-        let pattern = match pat.kind() {
-            ast::PatKind::BindPat(bp) => {
+        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.is_mutable(), bp.is_ref());
                 let subpat = bp.pat().map(|subpat| self.collect_pat(subpat));
                 Pat::Bind { name, mode: annotation, subpat }
             }
-            ast::PatKind::TupleStructPat(p) => {
+            ast::Pat::TupleStructPat(p) => {
                 let path = p.path().and_then(Path::from_ast);
                 let args = p.args().map(|p| self.collect_pat(p)).collect();
                 Pat::TupleStruct { path, args }
             }
-            ast::PatKind::RefPat(p) => {
+            ast::Pat::RefPat(p) => {
                 let pat = self.collect_pat_opt(p.pat());
                 let mutability = Mutability::from_mutable(p.is_mut());
                 Pat::Ref { pat, mutability }
             }
-            ast::PatKind::PathPat(p) => {
+            ast::Pat::PathPat(p) => {
                 let path = p.path().and_then(Path::from_ast);
                 path.map(Pat::Path).unwrap_or(Pat::Missing)
             }
-            ast::PatKind::TuplePat(p) => {
+            ast::Pat::TuplePat(p) => {
                 let args = p.args().map(|p| self.collect_pat(p)).collect();
                 Pat::Tuple(args)
             }
-            ast::PatKind::PlaceholderPat(_) => Pat::Wild,
-            ast::PatKind::StructPat(p) => {
+            ast::Pat::PlaceholderPat(_) => Pat::Wild,
+            ast::Pat::StructPat(p) => {
                 let path = p.path().and_then(Path::from_ast);
                 let field_pat_list =
                     p.field_pat_list().expect("every struct should have a field list");
@@ -1022,8 +1020,8 @@ where
             }
 
             // FIXME: implement
-            ast::PatKind::LiteralPat(_) => Pat::Missing,
-            ast::PatKind::SlicePat(_) | ast::PatKind::RangePat(_) => Pat::Missing,
+            ast::Pat::LiteralPat(_) => Pat::Missing,
+            ast::Pat::SlicePat(_) | ast::Pat::RangePat(_) => Pat::Missing,
         };
         let ptr = AstPtr::new(&pat);
         self.alloc_pat(pattern, Either::A(ptr))
diff --git a/crates/ra_hir/src/generics.rs b/crates/ra_hir/src/generics.rs
index bcbb4988d5c5..e6482180d5cb 100644
--- a/crates/ra_hir/src/generics.rs
+++ b/crates/ra_hir/src/generics.rs
@@ -137,8 +137,8 @@ impl GenericParams {
     fn add_where_predicate_from_bound(&mut self, bound: ast::TypeBound, type_ref: TypeRef) {
         let path = bound
             .type_ref()
-            .and_then(|tr| match tr.kind() {
-                ast::TypeRefKind::PathType(path) => path.path(),
+            .and_then(|tr| match tr {
+                ast::TypeRef::PathType(path) => path.path(),
                 _ => None,
             })
             .and_then(Path::from_ast);
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
index 8e62cf66d46c..62a41719a424 100644
--- a/crates/ra_hir/src/impl_block.rs
+++ b/crates/ra_hir/src/impl_block.rs
@@ -131,10 +131,10 @@ impl ImplData {
         let items = if let Some(item_list) = node.item_list() {
             item_list
                 .impl_items()
-                .map(|item_node| match item_node.kind() {
-                    ast::ImplItemKind::FnDef(it) => Function { id: ctx.to_def(&it) }.into(),
-                    ast::ImplItemKind::ConstDef(it) => Const { id: ctx.to_def(&it) }.into(),
-                    ast::ImplItemKind::TypeAliasDef(it) => TypeAlias { id: ctx.to_def(&it) }.into(),
+                .map(|item_node| match item_node {
+                    ast::ImplItem::FnDef(it) => Function { id: ctx.to_def(&it) }.into(),
+                    ast::ImplItem::ConstDef(it) => Const { id: ctx.to_def(&it) }.into(),
+                    ast::ImplItem::TypeAliasDef(it) => TypeAlias { id: ctx.to_def(&it) }.into(),
                 })
                 .collect()
         } else {
diff --git a/crates/ra_hir/src/nameres/raw.rs b/crates/ra_hir/src/nameres/raw.rs
index 584e15e290d6..2f973359fe02 100644
--- a/crates/ra_hir/src/nameres/raw.rs
+++ b/crates/ra_hir/src/nameres/raw.rs
@@ -207,24 +207,24 @@ impl RawItemsCollector {
     }
 
     fn add_item(&mut self, current_module: Option<Module>, item: ast::ModuleItem) {
-        let (kind, name) = match item.kind() {
-            ast::ModuleItemKind::Module(module) => {
+        let (kind, name) = match item {
+            ast::ModuleItem::Module(module) => {
                 self.add_module(current_module, module);
                 return;
             }
-            ast::ModuleItemKind::UseItem(use_item) => {
+            ast::ModuleItem::UseItem(use_item) => {
                 self.add_use_item(current_module, use_item);
                 return;
             }
-            ast::ModuleItemKind::ExternCrateItem(extern_crate) => {
+            ast::ModuleItem::ExternCrateItem(extern_crate) => {
                 self.add_extern_crate_item(current_module, extern_crate);
                 return;
             }
-            ast::ModuleItemKind::ImplBlock(_) => {
+            ast::ModuleItem::ImplBlock(_) => {
                 // impls don't participate in name resolution
                 return;
             }
-            ast::ModuleItemKind::StructDef(it) => {
+            ast::ModuleItem::StructDef(it) => {
                 let id = self.source_ast_id_map.ast_id(&it);
                 let name = it.name();
                 if it.is_union() {
@@ -233,22 +233,22 @@ impl RawItemsCollector {
                     (DefKind::Struct(id), name)
                 }
             }
-            ast::ModuleItemKind::EnumDef(it) => {
+            ast::ModuleItem::EnumDef(it) => {
                 (DefKind::Enum(self.source_ast_id_map.ast_id(&it)), it.name())
             }
-            ast::ModuleItemKind::FnDef(it) => {
+            ast::ModuleItem::FnDef(it) => {
                 (DefKind::Function(self.source_ast_id_map.ast_id(&it)), it.name())
             }
-            ast::ModuleItemKind::TraitDef(it) => {
+            ast::ModuleItem::TraitDef(it) => {
                 (DefKind::Trait(self.source_ast_id_map.ast_id(&it)), it.name())
             }
-            ast::ModuleItemKind::TypeAliasDef(it) => {
+            ast::ModuleItem::TypeAliasDef(it) => {
                 (DefKind::TypeAlias(self.source_ast_id_map.ast_id(&it)), it.name())
             }
-            ast::ModuleItemKind::ConstDef(it) => {
+            ast::ModuleItem::ConstDef(it) => {
                 (DefKind::Const(self.source_ast_id_map.ast_id(&it)), it.name())
             }
-            ast::ModuleItemKind::StaticDef(it) => {
+            ast::ModuleItem::StaticDef(it) => {
                 (DefKind::Static(self.source_ast_id_map.ast_id(&it)), it.name())
             }
         };
diff --git a/crates/ra_hir/src/traits.rs b/crates/ra_hir/src/traits.rs
index de26f1a68fed..6cdd3020afdd 100644
--- a/crates/ra_hir/src/traits.rs
+++ b/crates/ra_hir/src/traits.rs
@@ -30,10 +30,10 @@ impl TraitData {
         let items = if let Some(item_list) = src.ast.item_list() {
             item_list
                 .impl_items()
-                .map(|item_node| match item_node.kind() {
-                    ast::ImplItemKind::FnDef(it) => Function { id: ctx.to_def(&it) }.into(),
-                    ast::ImplItemKind::ConstDef(it) => Const { id: ctx.to_def(&it) }.into(),
-                    ast::ImplItemKind::TypeAliasDef(it) => TypeAlias { id: ctx.to_def(&it) }.into(),
+                .map(|item_node| match item_node {
+                    ast::ImplItem::FnDef(it) => Function { id: ctx.to_def(&it) }.into(),
+                    ast::ImplItem::ConstDef(it) => Const { id: ctx.to_def(&it) }.into(),
+                    ast::ImplItem::TypeAliasDef(it) => TypeAlias { id: ctx.to_def(&it) }.into(),
                 })
                 .collect()
         } else {
diff --git a/crates/ra_hir/src/type_ref.rs b/crates/ra_hir/src/type_ref.rs
index 8536ae44a155..b92a0b55acda 100644
--- a/crates/ra_hir/src/type_ref.rs
+++ b/crates/ra_hir/src/type_ref.rs
@@ -57,28 +57,33 @@ pub enum TypeRef {
 impl TypeRef {
     /// Converts an `ast::TypeRef` to a `hir::TypeRef`.
     pub(crate) fn from_ast(node: ast::TypeRef) -> Self {
-        use ra_syntax::ast::TypeRefKind::*;
-        match node.kind() {
-            ParenType(inner) => TypeRef::from_ast_opt(inner.type_ref()),
-            TupleType(inner) => TypeRef::Tuple(inner.fields().map(TypeRef::from_ast).collect()),
-            NeverType(..) => TypeRef::Never,
-            PathType(inner) => {
+        match node {
+            ast::TypeRef::ParenType(inner) => TypeRef::from_ast_opt(inner.type_ref()),
+            ast::TypeRef::TupleType(inner) => {
+                TypeRef::Tuple(inner.fields().map(TypeRef::from_ast).collect())
+            }
+            ast::TypeRef::NeverType(..) => TypeRef::Never,
+            ast::TypeRef::PathType(inner) => {
                 inner.path().and_then(Path::from_ast).map(TypeRef::Path).unwrap_or(TypeRef::Error)
             }
-            PointerType(inner) => {
+            ast::TypeRef::PointerType(inner) => {
                 let inner_ty = TypeRef::from_ast_opt(inner.type_ref());
                 let mutability = Mutability::from_mutable(inner.is_mut());
                 TypeRef::RawPtr(Box::new(inner_ty), mutability)
             }
-            ArrayType(inner) => TypeRef::Array(Box::new(TypeRef::from_ast_opt(inner.type_ref()))),
-            SliceType(inner) => TypeRef::Slice(Box::new(TypeRef::from_ast_opt(inner.type_ref()))),
-            ReferenceType(inner) => {
+            ast::TypeRef::ArrayType(inner) => {
+                TypeRef::Array(Box::new(TypeRef::from_ast_opt(inner.type_ref())))
+            }
+            ast::TypeRef::SliceType(inner) => {
+                TypeRef::Slice(Box::new(TypeRef::from_ast_opt(inner.type_ref())))
+            }
+            ast::TypeRef::ReferenceType(inner) => {
                 let inner_ty = TypeRef::from_ast_opt(inner.type_ref());
                 let mutability = Mutability::from_mutable(inner.is_mut());
                 TypeRef::Reference(Box::new(inner_ty), mutability)
             }
-            PlaceholderType(_inner) => TypeRef::Placeholder,
-            FnPointerType(inner) => {
+            ast::TypeRef::PlaceholderType(_inner) => TypeRef::Placeholder,
+            ast::TypeRef::FnPointerType(inner) => {
                 let ret_ty = TypeRef::from_ast_opt(inner.ret_type().and_then(|rt| rt.type_ref()));
                 let mut params = if let Some(pl) = inner.param_list() {
                     pl.params().map(|p| p.ascribed_type()).map(TypeRef::from_ast_opt).collect()
@@ -89,9 +94,9 @@ impl TypeRef {
                 TypeRef::Fn(params)
             }
             // for types are close enough for our purposes to the inner type for now...
-            ForType(inner) => TypeRef::from_ast_opt(inner.type_ref()),
-            ImplTraitType(_inner) => TypeRef::Error,
-            DynTraitType(_inner) => TypeRef::Error,
+            ast::TypeRef::ForType(inner) => TypeRef::from_ast_opt(inner.type_ref()),
+            ast::TypeRef::ImplTraitType(_inner) => TypeRef::Error,
+            ast::TypeRef::DynTraitType(_inner) => TypeRef::Error,
         }
     }
 
diff --git a/crates/ra_ide_api/src/call_info.rs b/crates/ra_ide_api/src/call_info.rs
index 212448d413b0..d5e116526634 100644
--- a/crates/ra_ide_api/src/call_info.rs
+++ b/crates/ra_ide_api/src/call_info.rs
@@ -91,8 +91,8 @@ impl 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 638f4cbde272..c5620dd522f6 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 0b3c96d26aa6..058cd68e291a 100644
--- a/crates/ra_ide_api/src/inlay_hints.rs
+++ b/crates/ra_ide_api/src/inlay_hints.rs
@@ -3,7 +3,7 @@ use hir::{HirDisplay, SourceAnalyzer, Ty};
 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 2118e7ad3e68..342e73fd344e 100644
--- a/crates/ra_ide_api/src/references.rs
+++ b/crates/ra_ide_api/src/references.rs
@@ -75,7 +75,7 @@ pub(crate) fn find_all_refs(
         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 09c082de9cfd..9ea96909e735 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"));
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 01666838077b..9c57897013ee 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -591,34 +591,7 @@ impl EnumVariantList {
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Expr {
-    pub(crate) syntax: SyntaxNode,
-}
-impl AstNode for Expr {
-    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            TUPLE_EXPR | ARRAY_EXPR | PAREN_EXPR | PATH_EXPR | LAMBDA_EXPR | IF_EXPR
-            | LOOP_EXPR | FOR_EXPR | WHILE_EXPR | CONTINUE_EXPR | BREAK_EXPR | LABEL
-            | BLOCK_EXPR | RETURN_EXPR | MATCH_EXPR | STRUCT_LIT | CALL_EXPR | INDEX_EXPR
-            | METHOD_CALL_EXPR | FIELD_EXPR | AWAIT_EXPR | TRY_EXPR | TRY_BLOCK_EXPR
-            | CAST_EXPR | REF_EXPR | PREFIX_EXPR | RANGE_EXPR | BIN_EXPR | LITERAL | MACRO_CALL => {
-                true
-            }
-            _ => false,
-        }
-    }
-    fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
-}
-pub enum ExprKind {
+pub enum Expr {
     TupleExpr(TupleExpr),
     ArrayExpr(ArrayExpr),
     ParenExpr(ParenExpr),
@@ -652,189 +625,235 @@ pub enum ExprKind {
 }
 impl From<TupleExpr> for Expr {
     fn from(node: TupleExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::TupleExpr(node)
     }
 }
 impl From<ArrayExpr> for Expr {
     fn from(node: ArrayExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::ArrayExpr(node)
     }
 }
 impl From<ParenExpr> for Expr {
     fn from(node: ParenExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::ParenExpr(node)
     }
 }
 impl From<PathExpr> for Expr {
     fn from(node: PathExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::PathExpr(node)
     }
 }
 impl From<LambdaExpr> for Expr {
     fn from(node: LambdaExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::LambdaExpr(node)
     }
 }
 impl From<IfExpr> for Expr {
     fn from(node: IfExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::IfExpr(node)
     }
 }
 impl From<LoopExpr> for Expr {
     fn from(node: LoopExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::LoopExpr(node)
     }
 }
 impl From<ForExpr> for Expr {
     fn from(node: ForExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::ForExpr(node)
     }
 }
 impl From<WhileExpr> for Expr {
     fn from(node: WhileExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::WhileExpr(node)
     }
 }
 impl From<ContinueExpr> for Expr {
     fn from(node: ContinueExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::ContinueExpr(node)
     }
 }
 impl From<BreakExpr> for Expr {
     fn from(node: BreakExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::BreakExpr(node)
     }
 }
 impl From<Label> for Expr {
     fn from(node: Label) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::Label(node)
     }
 }
 impl From<BlockExpr> for Expr {
     fn from(node: BlockExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::BlockExpr(node)
     }
 }
 impl From<ReturnExpr> for Expr {
     fn from(node: ReturnExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::ReturnExpr(node)
     }
 }
 impl From<MatchExpr> for Expr {
     fn from(node: MatchExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::MatchExpr(node)
     }
 }
 impl From<StructLit> for Expr {
     fn from(node: StructLit) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::StructLit(node)
     }
 }
 impl From<CallExpr> for Expr {
     fn from(node: CallExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::CallExpr(node)
     }
 }
 impl From<IndexExpr> for Expr {
     fn from(node: IndexExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::IndexExpr(node)
     }
 }
 impl From<MethodCallExpr> for Expr {
     fn from(node: MethodCallExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::MethodCallExpr(node)
     }
 }
 impl From<FieldExpr> for Expr {
     fn from(node: FieldExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::FieldExpr(node)
     }
 }
 impl From<AwaitExpr> for Expr {
     fn from(node: AwaitExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::AwaitExpr(node)
     }
 }
 impl From<TryExpr> for Expr {
     fn from(node: TryExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::TryExpr(node)
     }
 }
 impl From<TryBlockExpr> for Expr {
     fn from(node: TryBlockExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::TryBlockExpr(node)
     }
 }
 impl From<CastExpr> for Expr {
     fn from(node: CastExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::CastExpr(node)
     }
 }
 impl From<RefExpr> for Expr {
     fn from(node: RefExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::RefExpr(node)
     }
 }
 impl From<PrefixExpr> for Expr {
     fn from(node: PrefixExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::PrefixExpr(node)
     }
 }
 impl From<RangeExpr> for Expr {
     fn from(node: RangeExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::RangeExpr(node)
     }
 }
 impl From<BinExpr> for Expr {
     fn from(node: BinExpr) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::BinExpr(node)
     }
 }
 impl From<Literal> for Expr {
     fn from(node: Literal) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::Literal(node)
     }
 }
 impl From<MacroCall> for Expr {
     fn from(node: MacroCall) -> Expr {
-        Expr { syntax: node.syntax }
+        Expr::MacroCall(node)
     }
 }
-impl Expr {
-    pub fn kind(&self) -> ExprKind {
-        let syntax = self.syntax.clone();
-        match syntax.kind() {
-            TUPLE_EXPR => ExprKind::TupleExpr(TupleExpr { syntax }),
-            ARRAY_EXPR => ExprKind::ArrayExpr(ArrayExpr { syntax }),
-            PAREN_EXPR => ExprKind::ParenExpr(ParenExpr { syntax }),
-            PATH_EXPR => ExprKind::PathExpr(PathExpr { syntax }),
-            LAMBDA_EXPR => ExprKind::LambdaExpr(LambdaExpr { syntax }),
-            IF_EXPR => ExprKind::IfExpr(IfExpr { syntax }),
-            LOOP_EXPR => ExprKind::LoopExpr(LoopExpr { syntax }),
-            FOR_EXPR => ExprKind::ForExpr(ForExpr { syntax }),
-            WHILE_EXPR => ExprKind::WhileExpr(WhileExpr { syntax }),
-            CONTINUE_EXPR => ExprKind::ContinueExpr(ContinueExpr { syntax }),
-            BREAK_EXPR => ExprKind::BreakExpr(BreakExpr { syntax }),
-            LABEL => ExprKind::Label(Label { syntax }),
-            BLOCK_EXPR => ExprKind::BlockExpr(BlockExpr { syntax }),
-            RETURN_EXPR => ExprKind::ReturnExpr(ReturnExpr { syntax }),
-            MATCH_EXPR => ExprKind::MatchExpr(MatchExpr { syntax }),
-            STRUCT_LIT => ExprKind::StructLit(StructLit { syntax }),
-            CALL_EXPR => ExprKind::CallExpr(CallExpr { syntax }),
-            INDEX_EXPR => ExprKind::IndexExpr(IndexExpr { syntax }),
-            METHOD_CALL_EXPR => ExprKind::MethodCallExpr(MethodCallExpr { syntax }),
-            FIELD_EXPR => ExprKind::FieldExpr(FieldExpr { syntax }),
-            AWAIT_EXPR => ExprKind::AwaitExpr(AwaitExpr { syntax }),
-            TRY_EXPR => ExprKind::TryExpr(TryExpr { syntax }),
-            TRY_BLOCK_EXPR => ExprKind::TryBlockExpr(TryBlockExpr { syntax }),
-            CAST_EXPR => ExprKind::CastExpr(CastExpr { syntax }),
-            REF_EXPR => ExprKind::RefExpr(RefExpr { syntax }),
-            PREFIX_EXPR => ExprKind::PrefixExpr(PrefixExpr { syntax }),
-            RANGE_EXPR => ExprKind::RangeExpr(RangeExpr { syntax }),
-            BIN_EXPR => ExprKind::BinExpr(BinExpr { syntax }),
-            LITERAL => ExprKind::Literal(Literal { syntax }),
-            MACRO_CALL => ExprKind::MacroCall(MacroCall { syntax }),
-            _ => unreachable!(),
+impl AstNode for Expr {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            TUPLE_EXPR | ARRAY_EXPR | PAREN_EXPR | PATH_EXPR | LAMBDA_EXPR | IF_EXPR
+            | LOOP_EXPR | FOR_EXPR | WHILE_EXPR | CONTINUE_EXPR | BREAK_EXPR | LABEL
+            | BLOCK_EXPR | RETURN_EXPR | MATCH_EXPR | STRUCT_LIT | CALL_EXPR | INDEX_EXPR
+            | METHOD_CALL_EXPR | FIELD_EXPR | AWAIT_EXPR | TRY_EXPR | TRY_BLOCK_EXPR
+            | CAST_EXPR | REF_EXPR | PREFIX_EXPR | RANGE_EXPR | BIN_EXPR | LITERAL | MACRO_CALL => {
+                true
+            }
+            _ => false,
+        }
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        let res = match syntax.kind() {
+            TUPLE_EXPR => Expr::TupleExpr(TupleExpr { syntax }),
+            ARRAY_EXPR => Expr::ArrayExpr(ArrayExpr { syntax }),
+            PAREN_EXPR => Expr::ParenExpr(ParenExpr { syntax }),
+            PATH_EXPR => Expr::PathExpr(PathExpr { syntax }),
+            LAMBDA_EXPR => Expr::LambdaExpr(LambdaExpr { syntax }),
+            IF_EXPR => Expr::IfExpr(IfExpr { syntax }),
+            LOOP_EXPR => Expr::LoopExpr(LoopExpr { syntax }),
+            FOR_EXPR => Expr::ForExpr(ForExpr { syntax }),
+            WHILE_EXPR => Expr::WhileExpr(WhileExpr { syntax }),
+            CONTINUE_EXPR => Expr::ContinueExpr(ContinueExpr { syntax }),
+            BREAK_EXPR => Expr::BreakExpr(BreakExpr { syntax }),
+            LABEL => Expr::Label(Label { syntax }),
+            BLOCK_EXPR => Expr::BlockExpr(BlockExpr { syntax }),
+            RETURN_EXPR => Expr::ReturnExpr(ReturnExpr { syntax }),
+            MATCH_EXPR => Expr::MatchExpr(MatchExpr { syntax }),
+            STRUCT_LIT => Expr::StructLit(StructLit { syntax }),
+            CALL_EXPR => Expr::CallExpr(CallExpr { syntax }),
+            INDEX_EXPR => Expr::IndexExpr(IndexExpr { syntax }),
+            METHOD_CALL_EXPR => Expr::MethodCallExpr(MethodCallExpr { syntax }),
+            FIELD_EXPR => Expr::FieldExpr(FieldExpr { syntax }),
+            AWAIT_EXPR => Expr::AwaitExpr(AwaitExpr { syntax }),
+            TRY_EXPR => Expr::TryExpr(TryExpr { syntax }),
+            TRY_BLOCK_EXPR => Expr::TryBlockExpr(TryBlockExpr { syntax }),
+            CAST_EXPR => Expr::CastExpr(CastExpr { syntax }),
+            REF_EXPR => Expr::RefExpr(RefExpr { syntax }),
+            PREFIX_EXPR => Expr::PrefixExpr(PrefixExpr { syntax }),
+            RANGE_EXPR => Expr::RangeExpr(RangeExpr { syntax }),
+            BIN_EXPR => Expr::BinExpr(BinExpr { syntax }),
+            LITERAL => Expr::Literal(Literal { syntax }),
+            MACRO_CALL => Expr::MacroCall(MacroCall { syntax }),
+            _ => return None,
+        };
+        Some(res)
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        match self {
+            Expr::TupleExpr(it) => &it.syntax,
+            Expr::ArrayExpr(it) => &it.syntax,
+            Expr::ParenExpr(it) => &it.syntax,
+            Expr::PathExpr(it) => &it.syntax,
+            Expr::LambdaExpr(it) => &it.syntax,
+            Expr::IfExpr(it) => &it.syntax,
+            Expr::LoopExpr(it) => &it.syntax,
+            Expr::ForExpr(it) => &it.syntax,
+            Expr::WhileExpr(it) => &it.syntax,
+            Expr::ContinueExpr(it) => &it.syntax,
+            Expr::BreakExpr(it) => &it.syntax,
+            Expr::Label(it) => &it.syntax,
+            Expr::BlockExpr(it) => &it.syntax,
+            Expr::ReturnExpr(it) => &it.syntax,
+            Expr::MatchExpr(it) => &it.syntax,
+            Expr::StructLit(it) => &it.syntax,
+            Expr::CallExpr(it) => &it.syntax,
+            Expr::IndexExpr(it) => &it.syntax,
+            Expr::MethodCallExpr(it) => &it.syntax,
+            Expr::FieldExpr(it) => &it.syntax,
+            Expr::AwaitExpr(it) => &it.syntax,
+            Expr::TryExpr(it) => &it.syntax,
+            Expr::TryBlockExpr(it) => &it.syntax,
+            Expr::CastExpr(it) => &it.syntax,
+            Expr::RefExpr(it) => &it.syntax,
+            Expr::PrefixExpr(it) => &it.syntax,
+            Expr::RangeExpr(it) => &it.syntax,
+            Expr::BinExpr(it) => &it.syntax,
+            Expr::Literal(it) => &it.syntax,
+            Expr::MacroCall(it) => &it.syntax,
         }
     }
 }
@@ -1167,8 +1186,25 @@ impl ImplBlock {
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ImplItem {
-    pub(crate) syntax: SyntaxNode,
+pub enum ImplItem {
+    FnDef(FnDef),
+    TypeAliasDef(TypeAliasDef),
+    ConstDef(ConstDef),
+}
+impl From<FnDef> for ImplItem {
+    fn from(node: FnDef) -> ImplItem {
+        ImplItem::FnDef(node)
+    }
+}
+impl From<TypeAliasDef> for ImplItem {
+    fn from(node: TypeAliasDef) -> ImplItem {
+        ImplItem::TypeAliasDef(node)
+    }
+}
+impl From<ConstDef> for ImplItem {
+    fn from(node: ConstDef) -> ImplItem {
+        ImplItem::ConstDef(node)
+    }
 }
 impl AstNode for ImplItem {
     fn can_cast(kind: SyntaxKind) -> bool {
@@ -1178,44 +1214,19 @@ impl AstNode for ImplItem {
         }
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
+        let res = match syntax.kind() {
+            FN_DEF => ImplItem::FnDef(FnDef { syntax }),
+            TYPE_ALIAS_DEF => ImplItem::TypeAliasDef(TypeAliasDef { syntax }),
+            CONST_DEF => ImplItem::ConstDef(ConstDef { syntax }),
+            _ => return None,
+        };
+        Some(res)
     }
     fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
-}
-pub enum ImplItemKind {
-    FnDef(FnDef),
-    TypeAliasDef(TypeAliasDef),
-    ConstDef(ConstDef),
-}
-impl From<FnDef> for ImplItem {
-    fn from(node: FnDef) -> ImplItem {
-        ImplItem { syntax: node.syntax }
-    }
-}
-impl From<TypeAliasDef> for ImplItem {
-    fn from(node: TypeAliasDef) -> ImplItem {
-        ImplItem { syntax: node.syntax }
-    }
-}
-impl From<ConstDef> for ImplItem {
-    fn from(node: ConstDef) -> ImplItem {
-        ImplItem { syntax: node.syntax }
-    }
-}
-impl ImplItem {
-    pub fn kind(&self) -> ImplItemKind {
-        let syntax = self.syntax.clone();
-        match syntax.kind() {
-            FN_DEF => ImplItemKind::FnDef(FnDef { syntax }),
-            TYPE_ALIAS_DEF => ImplItemKind::TypeAliasDef(TypeAliasDef { syntax }),
-            CONST_DEF => ImplItemKind::ConstDef(ConstDef { syntax }),
-            _ => unreachable!(),
+        match self {
+            ImplItem::FnDef(it) => &it.syntax,
+            ImplItem::TypeAliasDef(it) => &it.syntax,
+            ImplItem::ConstDef(it) => &it.syntax,
         }
     }
 }
@@ -1774,29 +1785,7 @@ impl Module {
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ModuleItem {
-    pub(crate) syntax: SyntaxNode,
-}
-impl AstNode for ModuleItem {
-    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            STRUCT_DEF | ENUM_DEF | FN_DEF | TRAIT_DEF | TYPE_ALIAS_DEF | IMPL_BLOCK | USE_ITEM
-            | EXTERN_CRATE_ITEM | CONST_DEF | STATIC_DEF | MODULE => true,
-            _ => false,
-        }
-    }
-    fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
-}
-pub enum ModuleItemKind {
+pub enum ModuleItem {
     StructDef(StructDef),
     EnumDef(EnumDef),
     FnDef(FnDef),
@@ -1811,75 +1800,97 @@ pub enum ModuleItemKind {
 }
 impl From<StructDef> for ModuleItem {
     fn from(node: StructDef) -> ModuleItem {
-        ModuleItem { syntax: node.syntax }
+        ModuleItem::StructDef(node)
     }
 }
 impl From<EnumDef> for ModuleItem {
     fn from(node: EnumDef) -> ModuleItem {
-        ModuleItem { syntax: node.syntax }
+        ModuleItem::EnumDef(node)
     }
 }
 impl From<FnDef> for ModuleItem {
     fn from(node: FnDef) -> ModuleItem {
-        ModuleItem { syntax: node.syntax }
+        ModuleItem::FnDef(node)
     }
 }
 impl From<TraitDef> for ModuleItem {
     fn from(node: TraitDef) -> ModuleItem {
-        ModuleItem { syntax: node.syntax }
+        ModuleItem::TraitDef(node)
     }
 }
 impl From<TypeAliasDef> for ModuleItem {
     fn from(node: TypeAliasDef) -> ModuleItem {
-        ModuleItem { syntax: node.syntax }
+        ModuleItem::TypeAliasDef(node)
     }
 }
 impl From<ImplBlock> for ModuleItem {
     fn from(node: ImplBlock) -> ModuleItem {
-        ModuleItem { syntax: node.syntax }
+        ModuleItem::ImplBlock(node)
     }
 }
 impl From<UseItem> for ModuleItem {
     fn from(node: UseItem) -> ModuleItem {
-        ModuleItem { syntax: node.syntax }
+        ModuleItem::UseItem(node)
     }
 }
 impl From<ExternCrateItem> for ModuleItem {
     fn from(node: ExternCrateItem) -> ModuleItem {
-        ModuleItem { syntax: node.syntax }
+        ModuleItem::ExternCrateItem(node)
     }
 }
 impl From<ConstDef> for ModuleItem {
     fn from(node: ConstDef) -> ModuleItem {
-        ModuleItem { syntax: node.syntax }
+        ModuleItem::ConstDef(node)
     }
 }
 impl From<StaticDef> for ModuleItem {
     fn from(node: StaticDef) -> ModuleItem {
-        ModuleItem { syntax: node.syntax }
+        ModuleItem::StaticDef(node)
     }
 }
 impl From<Module> for ModuleItem {
     fn from(node: Module) -> ModuleItem {
-        ModuleItem { syntax: node.syntax }
+        ModuleItem::Module(node)
     }
 }
-impl ModuleItem {
-    pub fn kind(&self) -> ModuleItemKind {
-        let syntax = self.syntax.clone();
-        match syntax.kind() {
-            STRUCT_DEF => ModuleItemKind::StructDef(StructDef { syntax }),
-            ENUM_DEF => ModuleItemKind::EnumDef(EnumDef { syntax }),
-            FN_DEF => ModuleItemKind::FnDef(FnDef { syntax }),
-            TRAIT_DEF => ModuleItemKind::TraitDef(TraitDef { syntax }),
-            TYPE_ALIAS_DEF => ModuleItemKind::TypeAliasDef(TypeAliasDef { syntax }),
-            IMPL_BLOCK => ModuleItemKind::ImplBlock(ImplBlock { syntax }),
-            USE_ITEM => ModuleItemKind::UseItem(UseItem { syntax }),
-            EXTERN_CRATE_ITEM => ModuleItemKind::ExternCrateItem(ExternCrateItem { syntax }),
-            CONST_DEF => ModuleItemKind::ConstDef(ConstDef { syntax }),
-            STATIC_DEF => ModuleItemKind::StaticDef(StaticDef { syntax }),
-            MODULE => ModuleItemKind::Module(Module { syntax }),
-            _ => unreachable!(),
+impl AstNode for ModuleItem {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            STRUCT_DEF | ENUM_DEF | FN_DEF | TRAIT_DEF | TYPE_ALIAS_DEF | IMPL_BLOCK | USE_ITEM
+            | EXTERN_CRATE_ITEM | CONST_DEF | STATIC_DEF | MODULE => true,
+            _ => false,
+        }
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        let res = match syntax.kind() {
+            STRUCT_DEF => ModuleItem::StructDef(StructDef { syntax }),
+            ENUM_DEF => ModuleItem::EnumDef(EnumDef { syntax }),
+            FN_DEF => ModuleItem::FnDef(FnDef { syntax }),
+            TRAIT_DEF => ModuleItem::TraitDef(TraitDef { syntax }),
+            TYPE_ALIAS_DEF => ModuleItem::TypeAliasDef(TypeAliasDef { syntax }),
+            IMPL_BLOCK => ModuleItem::ImplBlock(ImplBlock { syntax }),
+            USE_ITEM => ModuleItem::UseItem(UseItem { syntax }),
+            EXTERN_CRATE_ITEM => ModuleItem::ExternCrateItem(ExternCrateItem { syntax }),
+            CONST_DEF => ModuleItem::ConstDef(ConstDef { syntax }),
+            STATIC_DEF => ModuleItem::StaticDef(StaticDef { syntax }),
+            MODULE => ModuleItem::Module(Module { syntax }),
+            _ => return None,
+        };
+        Some(res)
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        match self {
+            ModuleItem::StructDef(it) => &it.syntax,
+            ModuleItem::EnumDef(it) => &it.syntax,
+            ModuleItem::FnDef(it) => &it.syntax,
+            ModuleItem::TraitDef(it) => &it.syntax,
+            ModuleItem::TypeAliasDef(it) => &it.syntax,
+            ModuleItem::ImplBlock(it) => &it.syntax,
+            ModuleItem::UseItem(it) => &it.syntax,
+            ModuleItem::ExternCrateItem(it) => &it.syntax,
+            ModuleItem::ConstDef(it) => &it.syntax,
+            ModuleItem::StaticDef(it) => &it.syntax,
+            ModuleItem::Module(it) => &it.syntax,
         }
     }
 }
@@ -2069,8 +2080,19 @@ impl AstNode for NeverType {
 }
 impl NeverType {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NominalDef {
-    pub(crate) syntax: SyntaxNode,
+pub enum NominalDef {
+    StructDef(StructDef),
+    EnumDef(EnumDef),
+}
+impl From<StructDef> for NominalDef {
+    fn from(node: StructDef) -> NominalDef {
+        NominalDef::StructDef(node)
+    }
+}
+impl From<EnumDef> for NominalDef {
+    fn from(node: EnumDef) -> NominalDef {
+        NominalDef::EnumDef(node)
+    }
 }
 impl AstNode for NominalDef {
     fn can_cast(kind: SyntaxKind) -> bool {
@@ -2080,37 +2102,17 @@ impl AstNode for NominalDef {
         }
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
+        let res = match syntax.kind() {
+            STRUCT_DEF => NominalDef::StructDef(StructDef { syntax }),
+            ENUM_DEF => NominalDef::EnumDef(EnumDef { syntax }),
+            _ => return None,
+        };
+        Some(res)
     }
     fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
-}
-pub enum NominalDefKind {
-    StructDef(StructDef),
-    EnumDef(EnumDef),
-}
-impl From<StructDef> for NominalDef {
-    fn from(node: StructDef) -> NominalDef {
-        NominalDef { syntax: node.syntax }
-    }
-}
-impl From<EnumDef> for NominalDef {
-    fn from(node: EnumDef) -> NominalDef {
-        NominalDef { syntax: node.syntax }
-    }
-}
-impl NominalDef {
-    pub fn kind(&self) -> NominalDefKind {
-        let syntax = self.syntax.clone();
-        match syntax.kind() {
-            STRUCT_DEF => NominalDefKind::StructDef(StructDef { syntax }),
-            ENUM_DEF => NominalDefKind::EnumDef(EnumDef { syntax }),
-            _ => unreachable!(),
+        match self {
+            NominalDef::StructDef(it) => &it.syntax,
+            NominalDef::EnumDef(it) => &it.syntax,
         }
     }
 }
@@ -2232,29 +2234,7 @@ impl ParenType {
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Pat {
-    pub(crate) syntax: SyntaxNode,
-}
-impl AstNode for Pat {
-    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            REF_PAT | BIND_PAT | PLACEHOLDER_PAT | PATH_PAT | STRUCT_PAT | TUPLE_STRUCT_PAT
-            | TUPLE_PAT | SLICE_PAT | RANGE_PAT | LITERAL_PAT => true,
-            _ => false,
-        }
-    }
-    fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
-}
-pub enum PatKind {
+pub enum Pat {
     RefPat(RefPat),
     BindPat(BindPat),
     PlaceholderPat(PlaceholderPat),
@@ -2268,69 +2248,90 @@ pub enum PatKind {
 }
 impl From<RefPat> for Pat {
     fn from(node: RefPat) -> Pat {
-        Pat { syntax: node.syntax }
+        Pat::RefPat(node)
     }
 }
 impl From<BindPat> for Pat {
     fn from(node: BindPat) -> Pat {
-        Pat { syntax: node.syntax }
+        Pat::BindPat(node)
     }
 }
 impl From<PlaceholderPat> for Pat {
     fn from(node: PlaceholderPat) -> Pat {
-        Pat { syntax: node.syntax }
+        Pat::PlaceholderPat(node)
     }
 }
 impl From<PathPat> for Pat {
     fn from(node: PathPat) -> Pat {
-        Pat { syntax: node.syntax }
+        Pat::PathPat(node)
     }
 }
 impl From<StructPat> for Pat {
     fn from(node: StructPat) -> Pat {
-        Pat { syntax: node.syntax }
+        Pat::StructPat(node)
     }
 }
 impl From<TupleStructPat> for Pat {
     fn from(node: TupleStructPat) -> Pat {
-        Pat { syntax: node.syntax }
+        Pat::TupleStructPat(node)
     }
 }
 impl From<TuplePat> for Pat {
     fn from(node: TuplePat) -> Pat {
-        Pat { syntax: node.syntax }
+        Pat::TuplePat(node)
     }
 }
 impl From<SlicePat> for Pat {
     fn from(node: SlicePat) -> Pat {
-        Pat { syntax: node.syntax }
+        Pat::SlicePat(node)
     }
 }
 impl From<RangePat> for Pat {
     fn from(node: RangePat) -> Pat {
-        Pat { syntax: node.syntax }
+        Pat::RangePat(node)
     }
 }
 impl From<LiteralPat> for Pat {
     fn from(node: LiteralPat) -> Pat {
-        Pat { syntax: node.syntax }
+        Pat::LiteralPat(node)
     }
 }
-impl Pat {
-    pub fn kind(&self) -> PatKind {
-        let syntax = self.syntax.clone();
-        match syntax.kind() {
-            REF_PAT => PatKind::RefPat(RefPat { syntax }),
-            BIND_PAT => PatKind::BindPat(BindPat { syntax }),
-            PLACEHOLDER_PAT => PatKind::PlaceholderPat(PlaceholderPat { syntax }),
-            PATH_PAT => PatKind::PathPat(PathPat { syntax }),
-            STRUCT_PAT => PatKind::StructPat(StructPat { syntax }),
-            TUPLE_STRUCT_PAT => PatKind::TupleStructPat(TupleStructPat { syntax }),
-            TUPLE_PAT => PatKind::TuplePat(TuplePat { syntax }),
-            SLICE_PAT => PatKind::SlicePat(SlicePat { syntax }),
-            RANGE_PAT => PatKind::RangePat(RangePat { syntax }),
-            LITERAL_PAT => PatKind::LiteralPat(LiteralPat { syntax }),
-            _ => unreachable!(),
+impl AstNode for Pat {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            REF_PAT | BIND_PAT | PLACEHOLDER_PAT | PATH_PAT | STRUCT_PAT | TUPLE_STRUCT_PAT
+            | TUPLE_PAT | SLICE_PAT | RANGE_PAT | LITERAL_PAT => true,
+            _ => false,
+        }
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        let res = match syntax.kind() {
+            REF_PAT => Pat::RefPat(RefPat { syntax }),
+            BIND_PAT => Pat::BindPat(BindPat { syntax }),
+            PLACEHOLDER_PAT => Pat::PlaceholderPat(PlaceholderPat { syntax }),
+            PATH_PAT => Pat::PathPat(PathPat { syntax }),
+            STRUCT_PAT => Pat::StructPat(StructPat { syntax }),
+            TUPLE_STRUCT_PAT => Pat::TupleStructPat(TupleStructPat { syntax }),
+            TUPLE_PAT => Pat::TuplePat(TuplePat { syntax }),
+            SLICE_PAT => Pat::SlicePat(SlicePat { syntax }),
+            RANGE_PAT => Pat::RangePat(RangePat { syntax }),
+            LITERAL_PAT => Pat::LiteralPat(LiteralPat { syntax }),
+            _ => return None,
+        };
+        Some(res)
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        match self {
+            Pat::RefPat(it) => &it.syntax,
+            Pat::BindPat(it) => &it.syntax,
+            Pat::PlaceholderPat(it) => &it.syntax,
+            Pat::PathPat(it) => &it.syntax,
+            Pat::StructPat(it) => &it.syntax,
+            Pat::TupleStructPat(it) => &it.syntax,
+            Pat::TuplePat(it) => &it.syntax,
+            Pat::SlicePat(it) => &it.syntax,
+            Pat::RangePat(it) => &it.syntax,
+            Pat::LiteralPat(it) => &it.syntax,
         }
     }
 }
@@ -2951,8 +2952,19 @@ impl StaticDef {
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Stmt {
-    pub(crate) syntax: SyntaxNode,
+pub enum Stmt {
+    ExprStmt(ExprStmt),
+    LetStmt(LetStmt),
+}
+impl From<ExprStmt> for Stmt {
+    fn from(node: ExprStmt) -> Stmt {
+        Stmt::ExprStmt(node)
+    }
+}
+impl From<LetStmt> for Stmt {
+    fn from(node: LetStmt) -> Stmt {
+        Stmt::LetStmt(node)
+    }
 }
 impl AstNode for Stmt {
     fn can_cast(kind: SyntaxKind) -> bool {
@@ -2962,37 +2974,17 @@ impl AstNode for Stmt {
         }
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
+        let res = match syntax.kind() {
+            EXPR_STMT => Stmt::ExprStmt(ExprStmt { syntax }),
+            LET_STMT => Stmt::LetStmt(LetStmt { syntax }),
+            _ => return None,
+        };
+        Some(res)
     }
     fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
-}
-pub enum StmtKind {
-    ExprStmt(ExprStmt),
-    LetStmt(LetStmt),
-}
-impl From<ExprStmt> for Stmt {
-    fn from(node: ExprStmt) -> Stmt {
-        Stmt { syntax: node.syntax }
-    }
-}
-impl From<LetStmt> for Stmt {
-    fn from(node: LetStmt) -> Stmt {
-        Stmt { syntax: node.syntax }
-    }
-}
-impl Stmt {
-    pub fn kind(&self) -> StmtKind {
-        let syntax = self.syntax.clone();
-        match syntax.kind() {
-            EXPR_STMT => StmtKind::ExprStmt(ExprStmt { syntax }),
-            LET_STMT => StmtKind::LetStmt(LetStmt { syntax }),
-            _ => unreachable!(),
+        match self {
+            Stmt::ExprStmt(it) => &it.syntax,
+            Stmt::LetStmt(it) => &it.syntax,
         }
     }
 }
@@ -3508,30 +3500,7 @@ impl TypeParamList {
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TypeRef {
-    pub(crate) syntax: SyntaxNode,
-}
-impl AstNode for TypeRef {
-    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            PAREN_TYPE | TUPLE_TYPE | NEVER_TYPE | PATH_TYPE | POINTER_TYPE | ARRAY_TYPE
-            | SLICE_TYPE | REFERENCE_TYPE | PLACEHOLDER_TYPE | FN_POINTER_TYPE | FOR_TYPE
-            | IMPL_TRAIT_TYPE | DYN_TRAIT_TYPE => true,
-            _ => false,
-        }
-    }
-    fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
-}
-pub enum TypeRefKind {
+pub enum TypeRef {
     ParenType(ParenType),
     TupleType(TupleType),
     NeverType(NeverType),
@@ -3548,87 +3517,112 @@ pub enum TypeRefKind {
 }
 impl From<ParenType> for TypeRef {
     fn from(node: ParenType) -> TypeRef {
-        TypeRef { syntax: node.syntax }
+        TypeRef::ParenType(node)
     }
 }
 impl From<TupleType> for TypeRef {
     fn from(node: TupleType) -> TypeRef {
-        TypeRef { syntax: node.syntax }
+        TypeRef::TupleType(node)
     }
 }
 impl From<NeverType> for TypeRef {
     fn from(node: NeverType) -> TypeRef {
-        TypeRef { syntax: node.syntax }
+        TypeRef::NeverType(node)
     }
 }
 impl From<PathType> for TypeRef {
     fn from(node: PathType) -> TypeRef {
-        TypeRef { syntax: node.syntax }
+        TypeRef::PathType(node)
     }
 }
 impl From<PointerType> for TypeRef {
     fn from(node: PointerType) -> TypeRef {
-        TypeRef { syntax: node.syntax }
+        TypeRef::PointerType(node)
     }
 }
 impl From<ArrayType> for TypeRef {
     fn from(node: ArrayType) -> TypeRef {
-        TypeRef { syntax: node.syntax }
+        TypeRef::ArrayType(node)
     }
 }
 impl From<SliceType> for TypeRef {
     fn from(node: SliceType) -> TypeRef {
-        TypeRef { syntax: node.syntax }
+        TypeRef::SliceType(node)
     }
 }
 impl From<ReferenceType> for TypeRef {
     fn from(node: ReferenceType) -> TypeRef {
-        TypeRef { syntax: node.syntax }
+        TypeRef::ReferenceType(node)
     }
 }
 impl From<PlaceholderType> for TypeRef {
     fn from(node: PlaceholderType) -> TypeRef {
-        TypeRef { syntax: node.syntax }
+        TypeRef::PlaceholderType(node)
     }
 }
 impl From<FnPointerType> for TypeRef {
     fn from(node: FnPointerType) -> TypeRef {
-        TypeRef { syntax: node.syntax }
+        TypeRef::FnPointerType(node)
     }
 }
 impl From<ForType> for TypeRef {
     fn from(node: ForType) -> TypeRef {
-        TypeRef { syntax: node.syntax }
+        TypeRef::ForType(node)
     }
 }
 impl From<ImplTraitType> for TypeRef {
     fn from(node: ImplTraitType) -> TypeRef {
-        TypeRef { syntax: node.syntax }
+        TypeRef::ImplTraitType(node)
     }
 }
 impl From<DynTraitType> for TypeRef {
     fn from(node: DynTraitType) -> TypeRef {
-        TypeRef { syntax: node.syntax }
+        TypeRef::DynTraitType(node)
     }
 }
-impl TypeRef {
-    pub fn kind(&self) -> TypeRefKind {
-        let syntax = self.syntax.clone();
-        match syntax.kind() {
-            PAREN_TYPE => TypeRefKind::ParenType(ParenType { syntax }),
-            TUPLE_TYPE => TypeRefKind::TupleType(TupleType { syntax }),
-            NEVER_TYPE => TypeRefKind::NeverType(NeverType { syntax }),
-            PATH_TYPE => TypeRefKind::PathType(PathType { syntax }),
-            POINTER_TYPE => TypeRefKind::PointerType(PointerType { syntax }),
-            ARRAY_TYPE => TypeRefKind::ArrayType(ArrayType { syntax }),
-            SLICE_TYPE => TypeRefKind::SliceType(SliceType { syntax }),
-            REFERENCE_TYPE => TypeRefKind::ReferenceType(ReferenceType { syntax }),
-            PLACEHOLDER_TYPE => TypeRefKind::PlaceholderType(PlaceholderType { syntax }),
-            FN_POINTER_TYPE => TypeRefKind::FnPointerType(FnPointerType { syntax }),
-            FOR_TYPE => TypeRefKind::ForType(ForType { syntax }),
-            IMPL_TRAIT_TYPE => TypeRefKind::ImplTraitType(ImplTraitType { syntax }),
-            DYN_TRAIT_TYPE => TypeRefKind::DynTraitType(DynTraitType { syntax }),
-            _ => unreachable!(),
+impl AstNode for TypeRef {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            PAREN_TYPE | TUPLE_TYPE | NEVER_TYPE | PATH_TYPE | POINTER_TYPE | ARRAY_TYPE
+            | SLICE_TYPE | REFERENCE_TYPE | PLACEHOLDER_TYPE | FN_POINTER_TYPE | FOR_TYPE
+            | IMPL_TRAIT_TYPE | DYN_TRAIT_TYPE => true,
+            _ => false,
+        }
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        let res = match syntax.kind() {
+            PAREN_TYPE => TypeRef::ParenType(ParenType { syntax }),
+            TUPLE_TYPE => TypeRef::TupleType(TupleType { syntax }),
+            NEVER_TYPE => TypeRef::NeverType(NeverType { syntax }),
+            PATH_TYPE => TypeRef::PathType(PathType { syntax }),
+            POINTER_TYPE => TypeRef::PointerType(PointerType { syntax }),
+            ARRAY_TYPE => TypeRef::ArrayType(ArrayType { syntax }),
+            SLICE_TYPE => TypeRef::SliceType(SliceType { syntax }),
+            REFERENCE_TYPE => TypeRef::ReferenceType(ReferenceType { syntax }),
+            PLACEHOLDER_TYPE => TypeRef::PlaceholderType(PlaceholderType { syntax }),
+            FN_POINTER_TYPE => TypeRef::FnPointerType(FnPointerType { syntax }),
+            FOR_TYPE => TypeRef::ForType(ForType { syntax }),
+            IMPL_TRAIT_TYPE => TypeRef::ImplTraitType(ImplTraitType { syntax }),
+            DYN_TRAIT_TYPE => TypeRef::DynTraitType(DynTraitType { syntax }),
+            _ => return None,
+        };
+        Some(res)
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        match self {
+            TypeRef::ParenType(it) => &it.syntax,
+            TypeRef::TupleType(it) => &it.syntax,
+            TypeRef::NeverType(it) => &it.syntax,
+            TypeRef::PathType(it) => &it.syntax,
+            TypeRef::PointerType(it) => &it.syntax,
+            TypeRef::ArrayType(it) => &it.syntax,
+            TypeRef::SliceType(it) => &it.syntax,
+            TypeRef::ReferenceType(it) => &it.syntax,
+            TypeRef::PlaceholderType(it) => &it.syntax,
+            TypeRef::FnPointerType(it) => &it.syntax,
+            TypeRef::ForType(it) => &it.syntax,
+            TypeRef::ImplTraitType(it) => &it.syntax,
+            TypeRef::DynTraitType(it) => &it.syntax,
         }
     }
 }
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index 4c4e0580a5b3..2bced18678af 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -186,8 +186,8 @@ fn api_walkthrough() {
     // Let's fetch the `foo` function.
     let mut func = None;
     for item in file.items() {
-        match item.kind() {
-            ast::ModuleItemKind::FnDef(f) => func = Some(f),
+        match item {
+            ast::ModuleItem::FnDef(f) => func = Some(f),
             _ => unreachable!(),
         }
     }
@@ -206,12 +206,12 @@ fn api_walkthrough() {
     let block: ast::Block = func.body().unwrap();
     let expr: ast::Expr = block.expr().unwrap();
 
-    // "Enum"-like nodes are represented using the "kind" pattern. It allows us
-    // to match exhaustively against all flavors of nodes, while maintaining
-    // internal representation flexibility. The drawback is that one can't write
-    // nested matches as one pattern.
-    let bin_expr: ast::BinExpr = match expr.kind() {
-        ast::ExprKind::BinExpr(e) => e,
+    // Enums are used to group related ast nodes together, and can be used for
+    // matching. However, because there are no public fields, it's possible to
+    // match only the top level enum: that is the price we pay for increased API
+    // flexibility
+    let bin_expr: &ast::BinExpr = match &expr {
+        ast::Expr::BinExpr(e) => e,
         _ => unreachable!(),
     };
 
diff --git a/crates/ra_tools/src/boilerplate_gen.rs b/crates/ra_tools/src/boilerplate_gen.rs
index 486a3fdec452..01d092d4844a 100644
--- a/crates/ra_tools/src/boilerplate_gen.rs
+++ b/crates/ra_tools/src/boilerplate_gen.rs
@@ -37,41 +37,72 @@ fn generate_ast(grammar: &Grammar) -> Result<String> {
             ast_node.variants.iter().map(|var| format_ident!("{}", var)).collect::<Vec<_>>();
         let name = format_ident!("{}", name);
 
-        let kinds = if variants.is_empty() { vec![name.clone()] } else { variants.clone() }
-            .into_iter()
-            .map(|name| format_ident!("{}", name.to_string().to_shouty_snake_case()))
-            .collect::<Vec<_>>();
+        let adt = if variants.is_empty() {
+            let kind = format_ident!("{}", name.to_string().to_shouty_snake_case());
+            quote! {
+                #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+                pub struct #name {
+                    pub(crate) syntax: SyntaxNode,
+                }
 
-        let variants = if variants.is_empty() {
-            None
+                impl AstNode for #name {
+                    fn can_cast(kind: SyntaxKind) -> bool {
+                        match kind {
+                            #kind => true,
+                            _ => false,
+                        }
+                    }
+                    fn cast(syntax: SyntaxNode) -> Option<Self> {
+                        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
+                    }
+                    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+                }
+            }
         } else {
-            let kind_enum = format_ident!("{}Kind", name);
-            Some(quote!(
-                pub enum #kind_enum {
+            let kinds = variants
+                .iter()
+                .map(|name| format_ident!("{}", name.to_string().to_shouty_snake_case()))
+                .collect::<Vec<_>>();
+
+            quote! {
+                #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+                pub enum #name {
                     #(#variants(#variants),)*
                 }
 
                 #(
                 impl From<#variants> for #name {
                     fn from(node: #variants) -> #name {
-                        #name { syntax: node.syntax }
+                        #name::#variants(node)
                     }
                 }
                 )*
 
-                impl #name {
-                    pub fn kind(&self) -> #kind_enum {
-                        let syntax = self.syntax.clone();
-                        match syntax.kind() {
+                impl AstNode for #name {
+                    fn can_cast(kind: SyntaxKind) -> bool {
+                        match kind {
+                            #(#kinds)|* => true,
+                            _ => false,
+                        }
+                    }
+                    fn cast(syntax: SyntaxNode) -> Option<Self> {
+                        let res = match syntax.kind() {
                             #(
-                            #kinds =>
-                                #kind_enum::#variants(#variants { syntax }),
+                            #kinds => #name::#variants(#variants { syntax }),
+                            )*
+                            _ => return None,
+                        };
+                        Some(res)
+                    }
+                    fn syntax(&self) -> &SyntaxNode {
+                        match self {
+                            #(
+                            #name::#variants(it) => &it.syntax,
                             )*
-                            _ => unreachable!(),
                         }
                     }
                 }
-            ))
+            }
         };
 
         let traits = ast_node.traits.iter().map(|trait_name| {
@@ -105,25 +136,7 @@ fn generate_ast(grammar: &Grammar) -> Result<String> {
         });
 
         quote! {
-            #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-            pub struct #name {
-                pub(crate) syntax: SyntaxNode,
-            }
-
-            impl AstNode for #name {
-                fn can_cast(kind: SyntaxKind) -> bool {
-                    match kind {
-                        #(#kinds)|* => true,
-                        _ => false,
-                    }
-                }
-                fn cast(syntax: SyntaxNode) -> Option<Self> {
-                    if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
-                }
-                fn syntax(&self) -> &SyntaxNode { &self.syntax }
-            }
-
-            #variants
+            #adt
 
             #(#traits)*