13 files changed, 46 insertions, 45 deletions

diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index 5ea4f9f5b..28f3f3546 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -32,7 +32,7 @@ impl<'a> AstTransform<'a> for NullTransformer {
 
 pub struct SubstituteTypeParams<'a> {
     source_scope: &'a SemanticsScope<'a>,
-    substs: FxHashMap<hir::TypeParam, ast::TypeRef>,
+    substs: FxHashMap<hir::TypeParam, ast::Type>,
     previous: Box<dyn AstTransform<'a> + 'a>,
 }
 
@@ -79,19 +79,25 @@ impl<'a> SubstituteTypeParams<'a> {
         };
 
         // FIXME: It would probably be nicer if we could get this via HIR (i.e. get the
-        // trait ref, and then go from the types in the substs back to the syntax)
-        fn get_syntactic_substs(impl_def: ast::Impl) -> Option<Vec<ast::TypeRef>> {
-            let target_trait = impl_def.target_trait()?;
+        // trait ref, and then go from the types in the substs back to the syntax).
+        fn get_syntactic_substs(impl_def: ast::Impl) -> Option<Vec<ast::Type>> {
+            let target_trait = impl_def.trait_()?;
             let path_type = match target_trait {
-                ast::TypeRef::PathType(path) => path,
+                ast::Type::PathType(path) => path,
                 _ => return None,
             };
-            let type_arg_list = path_type.path()?.segment()?.type_arg_list()?;
+            let generic_arg_list = path_type.path()?.segment()?.generic_arg_list()?;
+
             let mut result = Vec::new();
-            for type_arg in type_arg_list.type_args() {
-                let type_arg: ast::TypeArg = type_arg;
-                result.push(type_arg.type_ref()?);
+            for generic_arg in generic_arg_list.generic_args() {
+                match generic_arg {
+                    ast::GenericArg::TypeArg(type_arg) => result.push(type_arg.ty()?),
+                    ast::GenericArg::AssocTypeArg(_)
+                    | ast::GenericArg::LifetimeArg(_)
+                    | ast::GenericArg::ConstArg(_) => (),
+                }
             }
+
             Some(result)
         }
     }
@@ -99,9 +105,9 @@ impl<'a> SubstituteTypeParams<'a> {
         &self,
         node: &ra_syntax::SyntaxNode,
     ) -> Option<ra_syntax::SyntaxNode> {
-        let type_ref = ast::TypeRef::cast(node.clone())?;
+        let type_ref = ast::Type::cast(node.clone())?;
         let path = match &type_ref {
-            ast::TypeRef::PathType(path_type) => path_type.path()?,
+            ast::Type::PathType(path_type) => path_type.path()?,
             _ => return None,
         };
         // FIXME: use `hir::Path::from_src` instead.
@@ -157,7 +163,7 @@ impl<'a> QualifyPaths<'a> {
 
                 let type_args = p
                     .segment()
-                    .and_then(|s| s.type_arg_list())
+                    .and_then(|s| s.generic_arg_list())
                     .map(|arg_list| apply(self, arg_list));
                 if let Some(type_args) = type_args {
                     let last_segment = path.segment().unwrap();
diff --git a/crates/ra_assists/src/handlers/add_explicit_type.rs b/crates/ra_assists/src/handlers/add_explicit_type.rs
index e69f0a89b..135a2ac9c 100644
--- a/crates/ra_assists/src/handlers/add_explicit_type.rs
+++ b/crates/ra_assists/src/handlers/add_explicit_type.rs
@@ -27,7 +27,7 @@ pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Optio
     let expr = let_stmt.initializer()?;
     // Must be a binding
     let pat = match let_stmt.pat()? {
-        ast::Pat::BindPat(bind_pat) => bind_pat,
+        ast::Pat::IdentPat(bind_pat) => bind_pat,
         _ => return None,
     };
     let pat_range = pat.syntax().text_range();
@@ -46,7 +46,7 @@ pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Optio
     // and it has no placeholders
     let ascribed_ty = let_stmt.ty();
     if let Some(ty) = &ascribed_ty {
-        if ty.syntax().descendants().find_map(ast::PlaceholderType::cast).is_none() {
+        if ty.syntax().descendants().find_map(ast::InferType::cast).is_none() {
             return None;
         }
     }
diff --git a/crates/ra_assists/src/handlers/change_return_type_to_result.rs b/crates/ra_assists/src/handlers/change_return_type_to_result.rs
index 167e162d8..b83c94404 100644
--- a/crates/ra_assists/src/handlers/change_return_type_to_result.rs
+++ b/crates/ra_assists/src/handlers/change_return_type_to_result.rs
@@ -74,6 +74,7 @@ impl TailReturnCollector {
             let expr = match &stmt {
                 ast::Stmt::ExprStmt(stmt) => stmt.expr(),
                 ast::Stmt::LetStmt(stmt) => stmt.initializer(),
+                ast::Stmt::Item(_) => continue,
             };
             if let Some(expr) = &expr {
                 self.handle_exprs(expr, collect_break);
@@ -94,6 +95,7 @@ impl TailReturnCollector {
                         let expr_stmt = match &expr_stmt {
                             ast::Stmt::ExprStmt(stmt) => stmt.expr(),
                             ast::Stmt::LetStmt(stmt) => stmt.initializer(),
+                            ast::Stmt::Item(_) => None,
                         };
                         if let Some(expr) = &expr_stmt {
                             self.handle_exprs(expr, collect_break);
@@ -239,7 +241,6 @@ fn get_tail_expr_from_block(expr: &Expr) -> Option<Vec<NodeType>> {
         Expr::ArrayExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
         Expr::ParenExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
         Expr::PathExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
-        Expr::Label(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
         Expr::RecordExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
         Expr::IndexExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
         Expr::MethodCallExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
diff --git a/crates/ra_assists/src/handlers/early_return.rs b/crates/ra_assists/src/handlers/early_return.rs
index 3650289fd..69852b611 100644
--- a/crates/ra_assists/src/handlers/early_return.rs
+++ b/crates/ra_assists/src/handlers/early_return.rs
@@ -51,11 +51,11 @@ pub(crate) fn convert_to_guarded_return(acc: &mut Assists, ctx: &AssistContext)
     // Check if there is an IfLet that we can handle.
     let if_let_pat = match cond.pat() {
         None => None, // No IfLet, supported.
-        Some(ast::Pat::TupleStructPat(pat)) if pat.args().count() == 1 => {
+        Some(ast::Pat::TupleStructPat(pat)) if pat.fields().count() == 1 => {
             let path = pat.path()?;
             match path.qualifier() {
                 None => {
-                    let bound_ident = pat.args().next().unwrap();
+                    let bound_ident = pat.fields().next().unwrap();
                     Some((path, bound_ident))
                 }
                 Some(_) => return None,
diff --git a/crates/ra_assists/src/handlers/extract_variable.rs b/crates/ra_assists/src/handlers/extract_variable.rs
index b925a2884..cc62db0c4 100644
--- a/crates/ra_assists/src/handlers/extract_variable.rs
+++ b/crates/ra_assists/src/handlers/extract_variable.rs
@@ -1,7 +1,7 @@
 use ra_syntax::{
     ast::{self, AstNode},
     SyntaxKind::{
-        BLOCK_EXPR, BREAK_EXPR, COMMENT, LAMBDA_EXPR, LOOP_EXPR, MATCH_ARM, PATH_EXPR, RETURN_EXPR,
+        BLOCK_EXPR, BREAK_EXPR, CLOSURE_EXPR, COMMENT, LOOP_EXPR, MATCH_ARM, PATH_EXPR, RETURN_EXPR,
     },
     SyntaxNode,
 };
@@ -148,7 +148,7 @@ impl Anchor {
             }
 
             if let Some(parent) = node.parent() {
-                if parent.kind() == MATCH_ARM || parent.kind() == LAMBDA_EXPR {
+                if parent.kind() == MATCH_ARM || parent.kind() == CLOSURE_EXPR {
                     return Some(Anchor::WrapInBlock(node));
                 }
             }
diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index 708e1bc6c..b2e14f9d7 100644
--- a/crates/ra_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -43,7 +43,7 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
 
     let mut arms: Vec<MatchArm> = match_arm_list.arms().collect();
     if arms.len() == 1 {
-        if let Some(Pat::PlaceholderPat(..)) = arms[0].pat() {
+        if let Some(Pat::WildcardPat(..)) = arms[0].pat() {
             arms.clear();
         }
     }
@@ -116,17 +116,15 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
             match (first_new_arm, ctx.config.snippet_cap) {
                 (Some(first_new_arm), Some(cap)) => {
                     let extend_lifetime;
-                    let cursor = match first_new_arm
-                        .syntax()
-                        .descendants()
-                        .find_map(ast::PlaceholderPat::cast)
-                    {
-                        Some(it) => {
-                            extend_lifetime = it.syntax().clone();
-                            Cursor::Replace(&extend_lifetime)
-                        }
-                        None => Cursor::Before(first_new_arm.syntax()),
-                    };
+                    let cursor =
+                        match first_new_arm.syntax().descendants().find_map(ast::WildcardPat::cast)
+                        {
+                            Some(it) => {
+                                extend_lifetime = it.syntax().clone();
+                                Cursor::Replace(&extend_lifetime)
+                            }
+                            None => Cursor::Before(first_new_arm.syntax()),
+                        };
                     let snippet = render_snippet(cap, new_arm_list.syntax(), cursor);
                     builder.replace_snippet(cap, old_range, snippet);
                 }
@@ -152,7 +150,7 @@ fn does_pat_match_variant(pat: &Pat, var: &Pat) -> bool {
     let first_node_text = |pat: &Pat| pat.syntax().first_child().map(|node| node.text());
 
     let pat_head = match pat {
-        Pat::BindPat(bind_pat) => {
+        Pat::IdentPat(bind_pat) => {
             if let Some(p) = bind_pat.pat() {
                 first_node_text(&p)
             } else {
diff --git a/crates/ra_assists/src/handlers/generate_from_impl_for_enum.rs b/crates/ra_assists/src/handlers/generate_from_impl_for_enum.rs
index 9da23640a..4c1aef8a2 100644
--- a/crates/ra_assists/src/handlers/generate_from_impl_for_enum.rs
+++ b/crates/ra_assists/src/handlers/generate_from_impl_for_enum.rs
@@ -34,7 +34,7 @@ pub(crate) fn generate_from_impl_for_enum(acc: &mut Assists, ctx: &AssistContext
     }
     let field_type = field_list.fields().next()?.ty()?;
     let path = match field_type {
-        ast::TypeRef::PathType(it) => it,
+        ast::Type::PathType(it) => it,
         _ => return None,
     };
 
diff --git a/crates/ra_assists/src/handlers/inline_local_variable.rs b/crates/ra_assists/src/handlers/inline_local_variable.rs
index 2fdfabaf5..3c58020f8 100644
--- a/crates/ra_assists/src/handlers/inline_local_variable.rs
+++ b/crates/ra_assists/src/handlers/inline_local_variable.rs
@@ -29,7 +29,7 @@ use crate::{
 pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let let_stmt = ctx.find_node_at_offset::<ast::LetStmt>()?;
     let bind_pat = match let_stmt.pat()? {
-        ast::Pat::BindPat(pat) => pat,
+        ast::Pat::IdentPat(pat) => pat,
         _ => return None,
     };
     if bind_pat.mut_token().is_some() {
diff --git a/crates/ra_assists/src/handlers/introduce_named_lifetime.rs b/crates/ra_assists/src/handlers/introduce_named_lifetime.rs
index c3134f64d..fbaf3c06b 100644
--- a/crates/ra_assists/src/handlers/introduce_named_lifetime.rs
+++ b/crates/ra_assists/src/handlers/introduce_named_lifetime.rs
@@ -68,7 +68,7 @@ fn generate_fn_def_assist(
         let fn_params_without_lifetime: Vec<_> = param_list
             .params()
             .filter_map(|param| match param.ty() {
-                Some(ast::TypeRef::ReferenceType(ascribed_type))
+                Some(ast::Type::RefType(ascribed_type))
                     if ascribed_type.lifetime_token() == None =>
                 {
                     Some(ascribed_type.amp_token()?.text_range().end())
diff --git a/crates/ra_assists/src/handlers/merge_match_arms.rs b/crates/ra_assists/src/handlers/merge_match_arms.rs
index 186a1f618..563292282 100644
--- a/crates/ra_assists/src/handlers/merge_match_arms.rs
+++ b/crates/ra_assists/src/handlers/merge_match_arms.rs
@@ -86,7 +86,7 @@ pub(crate) fn merge_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option
 }
 
 fn contains_placeholder(a: &ast::MatchArm) -> bool {
-    matches!(a.pat(), Some(ast::Pat::PlaceholderPat(..)))
+    matches!(a.pat(), Some(ast::Pat::WildcardPat(..)))
 }
 
 #[cfg(test)]
diff --git a/crates/ra_assists/src/handlers/reorder_fields.rs b/crates/ra_assists/src/handlers/reorder_fields.rs
index 120250e79..c9b743a06 100644
--- a/crates/ra_assists/src/handlers/reorder_fields.rs
+++ b/crates/ra_assists/src/handlers/reorder_fields.rs
@@ -57,7 +57,7 @@ fn reorder<R: AstNode>(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
 fn get_fields_kind(node: &SyntaxNode) -> Vec<SyntaxKind> {
     match node.kind() {
         RECORD_EXPR => vec![RECORD_EXPR_FIELD],
-        RECORD_PAT => vec![RECORD_FIELD_PAT, BIND_PAT],
+        RECORD_PAT => vec![RECORD_PAT_FIELD, IDENT_PAT],
         _ => vec![],
     }
 }
@@ -66,7 +66,7 @@ fn get_field_name(node: &SyntaxNode) -> String {
     let res = match_ast! {
         match node {
             ast::RecordExprField(field) => field.field_name().map(|it| it.to_string()),
-            ast::RecordFieldPat(field) => field.field_name().map(|it| it.to_string()),
+            ast::RecordPatField(field) => field.field_name().map(|it| it.to_string()),
             _ => None,
         }
     };
diff --git a/crates/ra_assists/src/handlers/replace_let_with_if_let.rs b/crates/ra_assists/src/handlers/replace_let_with_if_let.rs
index a49292c97..64ad15a23 100644
--- a/crates/ra_assists/src/handlers/replace_let_with_if_let.rs
+++ b/crates/ra_assists/src/handlers/replace_let_with_if_let.rs
@@ -62,8 +62,7 @@ pub(crate) fn replace_let_with_if_let(acc: &mut Assists, ctx: &AssistContext) ->
             let if_ = make::expr_if(make::condition(init, Some(with_placeholder)), block);
             let stmt = make::expr_stmt(if_);
 
-            let placeholder =
-                stmt.syntax().descendants().find_map(ast::PlaceholderPat::cast).unwrap();
+            let placeholder = stmt.syntax().descendants().find_map(ast::WildcardPat::cast).unwrap();
             let stmt = stmt.replace_descendant(placeholder.into(), original_pat);
 
             edit.replace_ast(ast::Stmt::from(let_stmt), ast::Stmt::from(stmt));
diff --git a/crates/ra_assists/src/utils.rs b/crates/ra_assists/src/utils.rs
index bb16ebd4e..373de273c 100644
--- a/crates/ra_assists/src/utils.rs
+++ b/crates/ra_assists/src/utils.rs
@@ -111,11 +111,8 @@ pub(crate) fn resolve_target_trait(
     sema: &Semantics<RootDatabase>,
     impl_def: &ast::Impl,
 ) -> Option<hir::Trait> {
-    let ast_path = impl_def
-        .target_trait()
-        .map(|it| it.syntax().clone())
-        .and_then(ast::PathType::cast)?
-        .path()?;
+    let ast_path =
+        impl_def.trait_().map(|it| it.syntax().clone()).and_then(ast::PathType::cast)?.path()?;
 
     match sema.resolve_path(&ast_path) {
         Some(hir::PathResolution::Def(hir::ModuleDef::Trait(def))) => Some(def),