462 files changed, 6459 insertions, 6421 deletions
diff --git a/crates/flycheck/Cargo.toml b/crates/flycheck/Cargo.toml
index bea485694..ff8a1e568 100644
--- a/crates/flycheck/Cargo.toml
+++ b/crates/flycheck/Cargo.toml
@@ -11,7 +11,7 @@ doctest = false
 [dependencies]
 crossbeam-channel = "0.4.0"
 log = "0.4.8"
-cargo_metadata = "0.10.0"
+cargo_metadata = "0.11.1"
 serde_json = "1.0.48"
 jod-thread = "0.1.1"
 ra_toolchain = { path = "../ra_toolchain" }
diff --git a/crates/flycheck/src/lib.rs b/crates/flycheck/src/lib.rs
index ad376ad18..7c38f5ef9 100644
--- a/crates/flycheck/src/lib.rs
+++ b/crates/flycheck/src/lib.rs
@@ -24,6 +24,7 @@ pub enum FlycheckConfig {
        command: String,
        target_triple: Option<String>,
        all_targets: bool,
+        no_default_features: bool,
        all_features: bool,
        features: Vec<String>,
        extra_args: Vec<String>,
@@ -180,6 +181,7 @@ impl FlycheckActor {
            FlycheckConfig::CargoCommand {
                command,
                target_triple,
+                no_default_features,
                all_targets,
                all_features,
                extra_args,
@@ -198,9 +200,14 @@ impl FlycheckActor {
                }
                if *all_features {
                    cmd.arg("--all-features");
-                } else if !features.is_empty() {
+                } else {
-                    cmd.arg("--features");
+                    if *no_default_features {
-                    cmd.arg(features.join(" "));
+                        cmd.arg("--no-default-features");
+                    }
+                    if !features.is_empty() {
+                        cmd.arg("--features");
+                        cmd.arg(features.join(" "));
+                    }
                }
                cmd.args(extra_args);
                cmd
diff --git a/crates/ra_assists/src/assist_context.rs b/crates/ra_assists/src/assist_context.rs
index 3407df856..afd3fd4b9 100644
--- a/crates/ra_assists/src/assist_context.rs
+++ b/crates/ra_assists/src/assist_context.rs
@@ -73,6 +73,10 @@ impl<'a> AssistContext<'a> {
        self.sema.db
    }
+    pub(crate) fn source_file(&self) -> &SourceFile {
+        &self.source_file
+    }
    // NB, this ignores active selection.
    pub(crate) fn offset(&self) -> TextSize {
        self.frange.range.start()
diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index 01adb834c..15ec75c95 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>,
 }
@@ -41,7 +41,7 @@ impl<'a> SubstituteTypeParams<'a> {
        source_scope: &'a SemanticsScope<'a>,
        // FIXME: there's implicit invariant that `trait_` and  `source_scope` match...
        trait_: hir::Trait,
-        impl_def: ast::ImplDef,
+        impl_def: ast::Impl,
    ) -> SubstituteTypeParams<'a> {
        let substs = get_syntactic_substs(impl_def).unwrap_or_default();
        let generic_def: hir::GenericDef = trait_.into();
@@ -63,7 +63,7 @@ impl<'a> SubstituteTypeParams<'a> {
                    let default = k.default(source_scope.db)?;
                    Some((
                        k,
-                        ast::make::type_ref(
+                        ast::make::ty(
                            &default
                                .display_source_code(source_scope.db, source_scope.module()?.into())
                                .ok()?,
@@ -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)
+        // trait ref, and then go from the types in the substs back to the syntax).
-        fn get_syntactic_substs(impl_def: ast::ImplDef) -> Option<Vec<ast::TypeRef>> {
+        fn get_syntactic_substs(impl_def: ast::Impl) -> Option<Vec<ast::Type>> {
-            let target_trait = impl_def.target_trait()?;
+            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() {
+            for generic_arg in generic_arg_list.generic_args() {
-                let type_arg: ast::TypeArg = type_arg;
+                match generic_arg {
-                result.push(type_arg.type_ref()?);
+                    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_custom_impl.rs b/crates/ra_assists/src/handlers/add_custom_impl.rs
index acb07e36a..b67438b6b 100644
--- a/crates/ra_assists/src/handlers/add_custom_impl.rs
+++ b/crates/ra_assists/src/handlers/add_custom_impl.rs
@@ -29,8 +29,8 @@ use crate::{
 // }
 // ```
 pub(crate) fn add_custom_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let input = ctx.find_node_at_offset::<ast::AttrInput>()?;
+    let attr = ctx.find_node_at_offset::<ast::Attr>()?;
-    let attr = input.syntax().parent().and_then(ast::Attr::cast)?;
+    let input = attr.token_tree()?;
    let attr_name = attr
        .syntax()
diff --git a/crates/ra_assists/src/handlers/add_explicit_type.rs b/crates/ra_assists/src/handlers/add_explicit_type.rs
index 39a5321d1..135a2ac9c 100644
--- a/crates/ra_assists/src/handlers/add_explicit_type.rs
+++ b/crates/ra_assists/src/handlers/add_explicit_type.rs
@@ -1,6 +1,6 @@
 use hir::HirDisplay;
 use ra_syntax::{
-    ast::{self, AstNode, LetStmt, NameOwner, TypeAscriptionOwner},
+    ast::{self, AstNode, LetStmt, NameOwner},
    TextRange,
 };
@@ -22,20 +22,20 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // }
 // ```
 pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let stmt = ctx.find_node_at_offset::<LetStmt>()?;
+    let let_stmt = ctx.find_node_at_offset::<LetStmt>()?;
-    let module = ctx.sema.scope(stmt.syntax()).module()?;
+    let module = ctx.sema.scope(let_stmt.syntax()).module()?;
-    let expr = stmt.initializer()?;
+    let expr = let_stmt.initializer()?;
    // Must be a binding
-    let pat = match stmt.pat()? {
+    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();
    // The binding must have a name
    let name = pat.name()?;
    let name_range = name.syntax().text_range();
-    let stmt_range = stmt.syntax().text_range();
+    let stmt_range = let_stmt.syntax().text_range();
-    let eq_range = stmt.eq_token()?.text_range();
+    let eq_range = let_stmt.eq_token()?.text_range();
    // Assist should only be applicable if cursor is between 'let' and '='
    let let_range = TextRange::new(stmt_range.start(), eq_range.start());
    let cursor_in_range = let_range.contains_range(ctx.frange.range);
@@ -44,9 +44,9 @@ pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Optio
    }
    // Assist not applicable if the type has already been specified
    // and it has no placeholders
-    let ascribed_ty = stmt.ascribed_type();
+    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/add_missing_impl_members.rs b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
index f185e61e5..95a750aee 100644
--- a/crates/ra_assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
@@ -111,16 +111,17 @@ fn add_missing_impl_members_inner(
    label: &'static str,
 ) -> Option<()> {
    let _p = ra_prof::profile("add_missing_impl_members_inner");
-    let impl_def = ctx.find_node_at_offset::<ast::ImplDef>()?;
+    let impl_def = ctx.find_node_at_offset::<ast::Impl>()?;
-    let impl_item_list = impl_def.item_list()?;
+    let impl_item_list = impl_def.assoc_item_list()?;
    let trait_ = resolve_target_trait(&ctx.sema, &impl_def)?;
    let def_name = |item: &ast::AssocItem| -> Option<SmolStr> {
        match item {
-            ast::AssocItem::FnDef(def) => def.name(),
+            ast::AssocItem::Fn(def) => def.name(),
-            ast::AssocItem::TypeAliasDef(def) => def.name(),
+            ast::AssocItem::TypeAlias(def) => def.name(),
-            ast::AssocItem::ConstDef(def) => def.name(),
+            ast::AssocItem::Const(def) => def.name(),
+            ast::AssocItem::MacroCall(_) => None,
        }
        .map(|it| it.text().clone())
    };
@@ -128,13 +129,13 @@ fn add_missing_impl_members_inner(
    let missing_items = get_missing_assoc_items(&ctx.sema, &impl_def)
        .iter()
        .map(|i| match i {
-            hir::AssocItem::Function(i) => ast::AssocItem::FnDef(i.source(ctx.db()).value),
+            hir::AssocItem::Function(i) => ast::AssocItem::Fn(i.source(ctx.db()).value),
-            hir::AssocItem::TypeAlias(i) => ast::AssocItem::TypeAliasDef(i.source(ctx.db()).value),
+            hir::AssocItem::TypeAlias(i) => ast::AssocItem::TypeAlias(i.source(ctx.db()).value),
-            hir::AssocItem::Const(i) => ast::AssocItem::ConstDef(i.source(ctx.db()).value),
+            hir::AssocItem::Const(i) => ast::AssocItem::Const(i.source(ctx.db()).value),
        })
        .filter(|t| def_name(&t).is_some())
        .filter(|t| match t {
-            ast::AssocItem::FnDef(def) => match mode {
+            ast::AssocItem::Fn(def) => match mode {
                AddMissingImplMembersMode::DefaultMethodsOnly => def.body().is_some(),
                AddMissingImplMembersMode::NoDefaultMethods => def.body().is_none(),
            },
@@ -157,10 +158,8 @@ fn add_missing_impl_members_inner(
            .into_iter()
            .map(|it| ast_transform::apply(&*ast_transform, it))
            .map(|it| match it {
-                ast::AssocItem::FnDef(def) => ast::AssocItem::FnDef(add_body(def)),
+                ast::AssocItem::Fn(def) => ast::AssocItem::Fn(add_body(def)),
-                ast::AssocItem::TypeAliasDef(def) => {
+                ast::AssocItem::TypeAlias(def) => ast::AssocItem::TypeAlias(def.remove_bounds()),
-                    ast::AssocItem::TypeAliasDef(def.remove_bounds())
-                }
                _ => it,
            })
            .map(|it| edit::remove_attrs_and_docs(&it));
@@ -173,7 +172,7 @@ fn add_missing_impl_members_inner(
            Some(cap) => {
                let mut cursor = Cursor::Before(first_new_item.syntax());
                let placeholder;
-                if let ast::AssocItem::FnDef(func) = &first_new_item {
+                if let ast::AssocItem::Fn(func) = &first_new_item {
                    if let Some(m) = func.syntax().descendants().find_map(ast::MacroCall::cast) {
                        if m.syntax().text() == "todo!()" {
                            placeholder = m;
@@ -191,7 +190,7 @@ fn add_missing_impl_members_inner(
    })
 }
-fn add_body(fn_def: ast::FnDef) -> ast::FnDef {
+fn add_body(fn_def: ast::Fn) -> ast::Fn {
    if fn_def.body().is_some() {
        return fn_def;
    }
diff --git a/crates/ra_assists/src/handlers/auto_import.rs b/crates/ra_assists/src/handlers/auto_import.rs
index 947be3b9b..01e7b7a44 100644
--- a/crates/ra_assists/src/handlers/auto_import.rs
+++ b/crates/ra_assists/src/handlers/auto_import.rs
@@ -92,7 +92,7 @@ impl AutoImportAssets {
    fn for_regular_path(path_under_caret: ast::Path, ctx: &AssistContext) -> Option<Self> {
        let syntax_under_caret = path_under_caret.syntax().to_owned();
-        if syntax_under_caret.ancestors().find_map(ast::UseItem::cast).is_some() {
+        if syntax_under_caret.ancestors().find_map(ast::Use::cast).is_some() {
            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 def00f7d8..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
@@ -20,9 +20,9 @@ use test_utils::mark;
 pub(crate) fn change_return_type_to_result(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let ret_type = ctx.find_node_at_offset::<ast::RetType>()?;
    // FIXME: extend to lambdas as well
-    let fn_def = ret_type.syntax().parent().and_then(ast::FnDef::cast)?;
+    let fn_def = ret_type.syntax().parent().and_then(ast::Fn::cast)?;
-    let type_ref = &ret_type.type_ref()?;
+    let type_ref = &ret_type.ty()?;
    let ret_type_str = type_ref.syntax().text().to_string();
    let first_part_ret_type = ret_type_str.splitn(2, '<').next();
    if let Some(ret_type_first_part) = first_part_ret_type {
@@ -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,8 +241,7 @@ 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::RecordLit(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())]),
        Expr::AwaitExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
diff --git a/crates/ra_assists/src/handlers/change_visibility.rs b/crates/ra_assists/src/handlers/change_visibility.rs
index 4343b423c..724daa93f 100644
--- a/crates/ra_assists/src/handlers/change_visibility.rs
+++ b/crates/ra_assists/src/handlers/change_visibility.rs
@@ -1,9 +1,7 @@
 use ra_syntax::{
    ast::{self, NameOwner, VisibilityOwner},
    AstNode,
-    SyntaxKind::{
+    SyntaxKind::{CONST, ENUM, FN, MODULE, STATIC, STRUCT, TRAIT, VISIBILITY},
-        CONST_DEF, ENUM_DEF, FN_DEF, MODULE, STATIC_DEF, STRUCT_DEF, TRAIT_DEF, VISIBILITY,
-    },
    T,
 };
 use test_utils::mark;
@@ -38,7 +36,7 @@ fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let (offset, target) = if let Some(keyword) = item_keyword {
        let parent = keyword.parent();
-        let def_kws = vec![CONST_DEF, STATIC_DEF, FN_DEF, MODULE, STRUCT_DEF, ENUM_DEF, TRAIT_DEF];
+        let def_kws = vec![CONST, STATIC, FN, MODULE, STRUCT, ENUM, TRAIT];
        // Parent is not a definition, can't add visibility
        if !def_kws.iter().any(|&def_kw| def_kw == parent.kind()) {
            return None;
@@ -49,7 +47,7 @@ fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
        }
        (vis_offset(&parent), keyword.text_range())
    } else if let Some(field_name) = ctx.find_node_at_offset::<ast::Name>() {
-        let field = field_name.syntax().ancestors().find_map(ast::RecordFieldDef::cast)?;
+        let field = field_name.syntax().ancestors().find_map(ast::RecordField::cast)?;
        if field.name()? != field_name {
            mark::hit!(change_visibility_field_false_positive);
            return None;
@@ -58,7 +56,7 @@ fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
            return None;
        }
        (vis_offset(field.syntax()), field_name.syntax().text_range())
-    } else if let Some(field) = ctx.find_node_at_offset::<ast::TupleFieldDef>() {
+    } else if let Some(field) = ctx.find_node_at_offset::<ast::TupleField>() {
        if field.visibility().is_some() {
            return None;
        }
diff --git a/crates/ra_assists/src/handlers/early_return.rs b/crates/ra_assists/src/handlers/early_return.rs
index 330459f3c..6816a2709 100644
--- a/crates/ra_assists/src/handlers/early_return.rs
+++ b/crates/ra_assists/src/handlers/early_return.rs
@@ -8,7 +8,7 @@ use ra_syntax::{
        make,
    },
    AstNode,
-    SyntaxKind::{FN_DEF, LOOP_EXPR, L_CURLY, R_CURLY, WHILE_EXPR, WHITESPACE},
+    SyntaxKind::{FN, LOOP_EXPR, L_CURLY, R_CURLY, WHILE_EXPR, WHITESPACE},
    SyntaxNode,
 };
@@ -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,
@@ -88,7 +88,7 @@ pub(crate) fn convert_to_guarded_return(acc: &mut Assists, ctx: &AssistContext)
    let early_expression: ast::Expr = match parent_container.kind() {
        WHILE_EXPR | LOOP_EXPR => make::expr_continue(),
-        FN_DEF => make::expr_return(),
+        FN => make::expr_return(),
        _ => return None,
    };
@@ -123,7 +123,7 @@ pub(crate) fn convert_to_guarded_return(acc: &mut Assists, ctx: &AssistContext)
                        let happy_arm = {
                            let pat = make::tuple_struct_pat(
                                path,
-                                once(make::bind_pat(make::name("it")).into()),
+                                once(make::ident_pat(make::name("it")).into()),
                            );
                            let expr = {
                                let name_ref = make::name_ref("it");
@@ -136,7 +136,7 @@ pub(crate) fn convert_to_guarded_return(acc: &mut Assists, ctx: &AssistContext)
                        let sad_arm = make::match_arm(
                            // FIXME: would be cool to use `None` or `Err(_)` if appropriate
-                            once(make::placeholder_pat().into()),
+                            once(make::wildcard_pat().into()),
                            early_expression,
                        );
@@ -144,7 +144,7 @@ pub(crate) fn convert_to_guarded_return(acc: &mut Assists, ctx: &AssistContext)
                    };
                    let let_stmt = make::let_stmt(
-                        make::bind_pat(make::name(&bound_ident.syntax().to_string())).into(),
+                        make::ident_pat(make::name(&bound_ident.syntax().to_string())).into(),
                        Some(match_expr),
                    );
                    let let_stmt = let_stmt.indent(if_indent_level);
diff --git a/crates/ra_assists/src/handlers/expand_glob_import.rs b/crates/ra_assists/src/handlers/expand_glob_import.rs
new file mode 100644
index 000000000..eb216a81a
--- /dev/null
+++ b/crates/ra_assists/src/handlers/expand_glob_import.rs
@@ -0,0 +1,391 @@
+use hir::{AssocItem, MacroDef, ModuleDef, Name, PathResolution, ScopeDef, SemanticsScope};
+use ra_ide_db::{
+    defs::{classify_name_ref, Definition, NameRefClass},
+    RootDatabase,
+};
+use ra_syntax::{algo, ast, match_ast, AstNode, SyntaxNode, SyntaxToken, T};
+use crate::{
+    assist_context::{AssistBuilder, AssistContext, Assists},
+    AssistId, AssistKind,
+};
+use either::Either;
+// Assist: expand_glob_import
+//
+// Expands glob imports.
+//
+// ```
+// mod foo {
+//     pub struct Bar;
+//     pub struct Baz;
+// }
+//
+// use foo::*<|>;
+//
+// fn qux(bar: Bar, baz: Baz) {}
+// ```
+// ->
+// ```
+// mod foo {
+//     pub struct Bar;
+//     pub struct Baz;
+// }
+//
+// use foo::{Baz, Bar};
+//
+// fn qux(bar: Bar, baz: Baz) {}
+// ```
+pub(crate) fn expand_glob_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let star = ctx.find_token_at_offset(T![*])?;
+    let mod_path = find_mod_path(&star)?;
+    let source_file = ctx.source_file();
+    let scope = ctx.sema.scope_at_offset(source_file.syntax(), ctx.offset());
+    let defs_in_mod = find_defs_in_mod(ctx, scope, &mod_path)?;
+    let name_refs_in_source_file =
+        source_file.syntax().descendants().filter_map(ast::NameRef::cast).collect();
+    let used_names = find_used_names(ctx, defs_in_mod, name_refs_in_source_file);
+    let parent = star.parent().parent()?;
+    acc.add(
+        AssistId("expand_glob_import", AssistKind::RefactorRewrite),
+        "Expand glob import",
+        parent.text_range(),
+        |builder| {
+            replace_ast(builder, &parent, mod_path, used_names);
+        },
+    )
+}
+fn find_mod_path(star: &SyntaxToken) -> Option<ast::Path> {
+    star.ancestors().find_map(|n| ast::UseTree::cast(n).and_then(|u| u.path()))
+}
+#[derive(PartialEq)]
+enum Def {
+    ModuleDef(ModuleDef),
+    MacroDef(MacroDef),
+}
+impl Def {
+    fn name(&self, db: &RootDatabase) -> Option<Name> {
+        match self {
+            Def::ModuleDef(def) => def.name(db),
+            Def::MacroDef(def) => def.name(db),
+        }
+    }
+}
+fn find_defs_in_mod(
+    ctx: &AssistContext,
+    from: SemanticsScope<'_>,
+    path: &ast::Path,
+) -> Option<Vec<Def>> {
+    let hir_path = ctx.sema.lower_path(&path)?;
+    let module = if let Some(PathResolution::Def(ModuleDef::Module(module))) =
+        from.resolve_hir_path_qualifier(&hir_path)
+    {
+        module
+    } else {
+        return None;
+    };
+    let module_scope = module.scope(ctx.db(), from.module());
+    let mut defs = vec![];
+    for (_, def) in module_scope {
+        match def {
+            ScopeDef::ModuleDef(def) => defs.push(Def::ModuleDef(def)),
+            ScopeDef::MacroDef(def) => defs.push(Def::MacroDef(def)),
+            _ => continue,
+        }
+    }
+    Some(defs)
+}
+fn find_used_names(
+    ctx: &AssistContext,
+    defs_in_mod: Vec<Def>,
+    name_refs_in_source_file: Vec<ast::NameRef>,
+) -> Vec<Name> {
+    let defs_in_source_file = name_refs_in_source_file
+        .iter()
+        .filter_map(|r| classify_name_ref(&ctx.sema, r))
+        .filter_map(|rc| match rc {
+            NameRefClass::Definition(Definition::ModuleDef(def)) => Some(Def::ModuleDef(def)),
+            NameRefClass::Definition(Definition::Macro(def)) => Some(Def::MacroDef(def)),
+            _ => None,
+        })
+        .collect::<Vec<Def>>();
+    defs_in_mod
+        .iter()
+        .filter(|def| {
+            if let Def::ModuleDef(ModuleDef::Trait(tr)) = def {
+                for item in tr.items(ctx.db()) {
+                    if let AssocItem::Function(f) = item {
+                        if defs_in_source_file.contains(&Def::ModuleDef(ModuleDef::Function(f))) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            defs_in_source_file.contains(def)
+        })
+        .filter_map(|d| d.name(ctx.db()))
+        .collect()
+}
+fn replace_ast(
+    builder: &mut AssistBuilder,
+    node: &SyntaxNode,
+    path: ast::Path,
+    used_names: Vec<Name>,
+) {
+    let replacement: Either<ast::UseTree, ast::UseTreeList> = match used_names.as_slice() {
+        [name] => Either::Left(ast::make::use_tree(
+            ast::make::path_from_text(&format!("{}::{}", path, name)),
+            None,
+            None,
+            false,
+        )),
+        names => Either::Right(ast::make::use_tree_list(names.iter().map(|n| {
+            ast::make::use_tree(ast::make::path_from_text(&n.to_string()), None, None, false)
+        }))),
+    };
+    let mut replace_node = |replacement: Either<ast::UseTree, ast::UseTreeList>| {
+        algo::diff(node, &replacement.either(|u| u.syntax().clone(), |ut| ut.syntax().clone()))
+            .into_text_edit(builder.text_edit_builder());
+    };
+    match_ast! {
+        match node {
+            ast::UseTree(use_tree) => {
+                replace_node(replacement);
+            },
+            ast::UseTreeList(use_tree_list) => {
+                replace_node(replacement);
+            },
+            ast::Use(use_item) => {
+                builder.replace_ast(use_item, ast::make::use_(replacement.left_or_else(|ut| ast::make::use_tree(path, Some(ut), None, false))));
+            },
+            _ => {},
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+    use super::*;
+    #[test]
+    fn expanding_glob_import() {
+        check_assist(
+            expand_glob_import,
+            r"
+mod foo {
+    pub struct Bar;
+    pub struct Baz;
+    pub struct Qux;
+    pub fn f() {}
+}
+use foo::*<|>;
+fn qux(bar: Bar, baz: Baz) {
+    f();
+}
+",
+            r"
+mod foo {
+    pub struct Bar;
+    pub struct Baz;
+    pub struct Qux;
+    pub fn f() {}
+}
+use foo::{Baz, Bar, f};
+fn qux(bar: Bar, baz: Baz) {
+    f();
+}
+",
+        )
+    }
+    #[test]
+    fn expanding_glob_import_with_existing_explicit_names() {
+        check_assist(
+            expand_glob_import,
+            r"
+mod foo {
+    pub struct Bar;
+    pub struct Baz;
+    pub struct Qux;
+    pub fn f() {}
+}
+use foo::{*<|>, f};
+fn qux(bar: Bar, baz: Baz) {
+    f();
+}
+",
+            r"
+mod foo {
+    pub struct Bar;
+    pub struct Baz;
+    pub struct Qux;
+    pub fn f() {}
+}
+use foo::{Baz, Bar, f};
+fn qux(bar: Bar, baz: Baz) {
+    f();
+}
+",
+        )
+    }
+    #[test]
+    fn expanding_nested_glob_import() {
+        check_assist(
+            expand_glob_import,
+            r"
+mod foo {
+    mod bar {
+        pub struct Bar;
+        pub struct Baz;
+        pub struct Qux;
+        pub fn f() {}
+    }
+    mod baz {
+        pub fn g() {}
+    }
+}
+use foo::{bar::{*<|>, f}, baz::*};
+fn qux(bar: Bar, baz: Baz) {
+    f();
+    g();
+}
+",
+            r"
+mod foo {
+    mod bar {
+        pub struct Bar;
+        pub struct Baz;
+        pub struct Qux;
+        pub fn f() {}
+    }
+    mod baz {
+        pub fn g() {}
+    }
+}
+use foo::{bar::{Baz, Bar, f}, baz::*};
+fn qux(bar: Bar, baz: Baz) {
+    f();
+    g();
+}
+",
+        )
+    }
+    #[test]
+    fn expanding_glob_import_with_macro_defs() {
+        check_assist(
+            expand_glob_import,
+            r"
+//- /lib.rs crate:foo
+#[macro_export]
+macro_rules! bar {
+    () => ()
+}
+pub fn baz() {}
+//- /main.rs crate:main deps:foo
+use foo::*<|>;
+fn main() {
+    bar!();
+    baz();
+}
+",
+            r"
+use foo::{bar, baz};
+fn main() {
+    bar!();
+    baz();
+}
+",
+        )
+    }
+    #[test]
+    fn expanding_glob_import_with_trait_method_uses() {
+        check_assist(
+            expand_glob_import,
+            r"
+//- /lib.rs crate:foo
+pub trait Tr {
+    fn method(&self) {}
+}
+impl Tr for () {}
+//- /main.rs crate:main deps:foo
+use foo::*<|>;
+fn main() {
+    ().method();
+}
+",
+            r"
+use foo::Tr;
+fn main() {
+    ().method();
+}
+",
+        )
+    }
+    #[test]
+    fn expanding_is_not_applicable_if_cursor_is_not_in_star_token() {
+        check_assist_not_applicable(
+            expand_glob_import,
+            r"
+    mod foo {
+        pub struct Bar;
+        pub struct Baz;
+        pub struct Qux;
+    }
+    use foo::Bar<|>;
+    fn qux(bar: Bar, baz: Baz) {}
+    ",
+        )
+    }
+}
diff --git a/crates/ra_assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/ra_assists/src/handlers/extract_struct_from_enum_variant.rs
index 2b8e273b3..ccec688ca 100644
--- a/crates/ra_assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/ra_assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -31,7 +31,7 @@ pub(crate) fn extract_struct_from_enum_variant(
    acc: &mut Assists,
    ctx: &AssistContext,
 ) -> Option<()> {
-    let variant = ctx.find_node_at_offset::<ast::EnumVariant>()?;
+    let variant = ctx.find_node_at_offset::<ast::Variant>()?;
    let field_list = match variant.kind() {
        ast::StructKind::Tuple(field_list) => field_list,
        _ => return None,
diff --git a/crates/ra_assists/src/handlers/extract_variable.rs b/crates/ra_assists/src/handlers/extract_variable.rs
index 098adf078..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,
 };
@@ -45,7 +45,7 @@ pub(crate) fn extract_variable(acc: &mut Assists, ctx: &AssistContext) -> Option
        target,
        move |edit| {
            let field_shorthand =
-                match to_extract.syntax().parent().and_then(ast::RecordField::cast) {
+                match to_extract.syntax().parent().and_then(ast::RecordExprField::cast) {
                    Some(field) => field.name_ref(),
                    None => None,
                };
@@ -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..6698d1a27 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
+                    let cursor =
-                        .syntax()
+                        match first_new_arm.syntax().descendants().find_map(ast::WildcardPat::cast)
-                        .descendants()
+                        {
-                        .find_map(ast::PlaceholderPat::cast)
+                            Some(it) => {
-                    {
+                                extend_lifetime = it.syntax().clone();
-                        Some(it) => {
+                                Cursor::Replace(&extend_lifetime)
-                            extend_lifetime = it.syntax().clone();
+                            }
-                            Cursor::Replace(&extend_lifetime)
+                            None => Cursor::Before(first_new_arm.syntax()),
-                        }
+                        };
-                        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 {
@@ -199,12 +197,11 @@ fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::EnumVariant) -> O
    // FIXME: use HIR for this; it doesn't currently expose struct vs. tuple vs. unit variants though
    let pat: ast::Pat = match var.source(db).value.kind() {
        ast::StructKind::Tuple(field_list) => {
-            let pats =
+            let pats = iter::repeat(make::wildcard_pat().into()).take(field_list.fields().count());
-                iter::repeat(make::placeholder_pat().into()).take(field_list.fields().count());
            make::tuple_struct_pat(path, pats).into()
        }
        ast::StructKind::Record(field_list) => {
-            let pats = field_list.fields().map(|f| make::bind_pat(f.name().unwrap()).into());
+            let pats = field_list.fields().map(|f| make::ident_pat(f.name().unwrap()).into());
            make::record_pat(path, pats).into()
        }
        ast::StructKind::Unit => make::path_pat(path),
diff --git a/crates/ra_assists/src/handlers/fix_visibility.rs b/crates/ra_assists/src/handlers/fix_visibility.rs
index 1d3ed3c6a..1aefa79cc 100644
--- a/crates/ra_assists/src/handlers/fix_visibility.rs
+++ b/crates/ra_assists/src/handlers/fix_visibility.rs
@@ -82,7 +82,7 @@ fn add_vis_to_referenced_module_def(acc: &mut Assists, ctx: &AssistContext) -> O
 }
 fn add_vis_to_referenced_record_field(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let record_field: ast::RecordField = ctx.find_node_at_offset()?;
+    let record_field: ast::RecordExprField = ctx.find_node_at_offset()?;
    let (record_field_def, _) = ctx.sema.resolve_record_field(&record_field)?;
    let current_module = ctx.sema.scope(record_field.syntax()).module()?;
diff --git a/crates/ra_assists/src/handlers/generate_derive.rs b/crates/ra_assists/src/handlers/generate_derive.rs
index 6ccf39900..90ece9fab 100644
--- a/crates/ra_assists/src/handlers/generate_derive.rs
+++ b/crates/ra_assists/src/handlers/generate_derive.rs
@@ -26,7 +26,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // ```
 pub(crate) fn generate_derive(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let cap = ctx.config.snippet_cap?;
-    let nominal = ctx.find_node_at_offset::<ast::NominalDef>()?;
+    let nominal = ctx.find_node_at_offset::<ast::AdtDef>()?;
    let node_start = derive_insertion_offset(&nominal)?;
    let target = nominal.syntax().text_range();
    acc.add(
@@ -58,7 +58,7 @@ pub(crate) fn generate_derive(acc: &mut Assists, ctx: &AssistContext) -> Option<
 }
 // Insert `derive` after doc comments.
-fn derive_insertion_offset(nominal: &ast::NominalDef) -> Option<TextSize> {
+fn derive_insertion_offset(nominal: &ast::AdtDef) -> Option<TextSize> {
    let non_ws_child = nominal
        .syntax()
        .children_with_tokens()
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 a347e3c2e..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
@@ -22,7 +22,7 @@ use crate::{utils::FamousDefs, AssistContext, AssistId, AssistKind, Assists};
 // }
 // ```
 pub(crate) fn generate_from_impl_for_enum(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let variant = ctx.find_node_at_offset::<ast::EnumVariant>()?;
+    let variant = ctx.find_node_at_offset::<ast::Variant>()?;
    let variant_name = variant.name()?;
    let enum_name = variant.parent_enum().name()?;
    let field_list = match variant.kind() {
@@ -32,9 +32,9 @@ pub(crate) fn generate_from_impl_for_enum(acc: &mut Assists, ctx: &AssistContext
    if field_list.fields().count() != 1 {
        return None;
    }
-    let field_type = field_list.fields().next()?.type_ref()?;
+    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,
    };
@@ -69,7 +69,7 @@ impl From<{0}> for {1} {{
 fn existing_from_impl(
    sema: &'_ hir::Semantics<'_, RootDatabase>,
-    variant: &ast::EnumVariant,
+    variant: &ast::Variant,
 ) -> Option<()> {
    let variant = sema.to_def(variant)?;
    let enum_ = variant.parent_enum(sema.db);
diff --git a/crates/ra_assists/src/handlers/generate_function.rs b/crates/ra_assists/src/handlers/generate_function.rs
index b721b96bb..acc97e648 100644
--- a/crates/ra_assists/src/handlers/generate_function.rs
+++ b/crates/ra_assists/src/handlers/generate_function.rs
@@ -82,7 +82,7 @@ struct FunctionTemplate {
    insert_offset: TextSize,
    placeholder_expr: ast::MacroCall,
    leading_ws: String,
-    fn_def: ast::FnDef,
+    fn_def: ast::Fn,
    trailing_ws: String,
    file: FileId,
 }
@@ -104,7 +104,7 @@ impl FunctionTemplate {
 struct FunctionBuilder {
    target: GeneratedFunctionTarget,
    fn_name: ast::Name,
-    type_params: Option<ast::TypeParamList>,
+    type_params: Option<ast::GenericParamList>,
    params: ast::ParamList,
    file: FileId,
    needs_pub: bool,
@@ -142,7 +142,7 @@ impl FunctionBuilder {
        let fn_body = make::block_expr(vec![], Some(placeholder_expr));
        let visibility = if self.needs_pub { Some(make::visibility_pub_crate()) } else { None };
        let mut fn_def =
-            make::fn_def(visibility, self.fn_name, self.type_params, self.params, fn_body);
+            make::fn_(visibility, self.fn_name, self.type_params, self.params, fn_body);
        let leading_ws;
        let trailing_ws;
@@ -200,7 +200,7 @@ fn fn_args(
    ctx: &AssistContext,
    target_module: hir::Module,
    call: &ast::CallExpr,
-) -> Option<(Option<ast::TypeParamList>, ast::ParamList)> {
+) -> Option<(Option<ast::GenericParamList>, ast::ParamList)> {
    let mut arg_names = Vec::new();
    let mut arg_types = Vec::new();
    for arg in call.arg_list()?.args() {
diff --git a/crates/ra_assists/src/handlers/generate_impl.rs b/crates/ra_assists/src/handlers/generate_impl.rs
index cbbac1d7f..d9b87c9c0 100644
--- a/crates/ra_assists/src/handlers/generate_impl.rs
+++ b/crates/ra_assists/src/handlers/generate_impl.rs
@@ -1,4 +1,4 @@
-use ra_syntax::ast::{self, AstNode, NameOwner, TypeParamsOwner};
+use ra_syntax::ast::{self, AstNode, GenericParamsOwner, NameOwner};
 use stdx::{format_to, SepBy};
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -23,7 +23,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // }
 // ```
 pub(crate) fn generate_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let nominal = ctx.find_node_at_offset::<ast::NominalDef>()?;
+    let nominal = ctx.find_node_at_offset::<ast::AdtDef>()?;
    let name = nominal.name()?;
    let target = nominal.syntax().text_range();
    acc.add(
@@ -31,7 +31,7 @@ pub(crate) fn generate_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()
        format!("Generate impl for `{}`", name),
        target,
        |edit| {
-            let type_params = nominal.type_param_list();
+            let type_params = nominal.generic_param_list();
            let start_offset = nominal.syntax().text_range().end();
            let mut buf = String::new();
            buf.push_str("\n\nimpl");
diff --git a/crates/ra_assists/src/handlers/generate_new.rs b/crates/ra_assists/src/handlers/generate_new.rs
index e27def1d8..b84aa24b6 100644
--- a/crates/ra_assists/src/handlers/generate_new.rs
+++ b/crates/ra_assists/src/handlers/generate_new.rs
@@ -1,8 +1,6 @@
 use hir::Adt;
 use ra_syntax::{
-    ast::{
+    ast::{self, AstNode, GenericParamsOwner, NameOwner, StructKind, VisibilityOwner},
-        self, AstNode, NameOwner, StructKind, TypeAscriptionOwner, TypeParamsOwner, VisibilityOwner,
-    },
    T,
 };
 use stdx::{format_to, SepBy};
@@ -30,7 +28,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 //
 // ```
 pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let strukt = ctx.find_node_at_offset::<ast::StructDef>()?;
+    let strukt = ctx.find_node_at_offset::<ast::Struct>()?;
    // We want to only apply this to non-union structs with named fields
    let field_list = match strukt.kind() {
@@ -53,9 +51,7 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
        let params = field_list
            .fields()
-            .filter_map(|f| {
+            .filter_map(|f| Some(format!("{}: {}", f.name()?.syntax(), f.ty()?.syntax())))
-                Some(format!("{}: {}", f.name()?.syntax(), f.ascribed_type()?.syntax()))
-            })
            .sep_by(", ");
        let fields = field_list.fields().filter_map(|f| f.name()).sep_by(", ");
@@ -90,8 +86,8 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
 // Generates the surrounding `impl Type { <code> }` including type and lifetime
 // parameters
-fn generate_impl_text(strukt: &ast::StructDef, code: &str) -> String {
+fn generate_impl_text(strukt: &ast::Struct, code: &str) -> String {
-    let type_params = strukt.type_param_list();
+    let type_params = strukt.generic_param_list();
    let mut buf = String::with_capacity(code.len());
    buf.push_str("\n\nimpl");
    if let Some(type_params) = &type_params {
@@ -121,7 +117,7 @@ fn generate_impl_text(strukt: &ast::StructDef, code: &str) -> String {
 //
 // FIXME: change the new fn checking to a more semantic approach when that's more
 // viable (e.g. we process proc macros, etc)
-fn find_struct_impl(ctx: &AssistContext, strukt: &ast::StructDef) -> Option<Option<ast::ImplDef>> {
+fn find_struct_impl(ctx: &AssistContext, strukt: &ast::Struct) -> Option<Option<ast::Impl>> {
    let db = ctx.db();
    let module = strukt.syntax().ancestors().find(|node| {
        ast::Module::can_cast(node.kind()) || ast::SourceFile::can_cast(node.kind())
@@ -129,7 +125,7 @@ fn find_struct_impl(ctx: &AssistContext, strukt: &ast::StructDef) -> Option<Opti
    let struct_def = ctx.sema.to_def(strukt)?;
-    let block = module.descendants().filter_map(ast::ImplDef::cast).find_map(|impl_blk| {
+    let block = module.descendants().filter_map(ast::Impl::cast).find_map(|impl_blk| {
        let blk = ctx.sema.to_def(&impl_blk)?;
        // FIXME: handle e.g. `struct S<T>; impl<U> S<U> {}`
@@ -157,10 +153,10 @@ fn find_struct_impl(ctx: &AssistContext, strukt: &ast::StructDef) -> Option<Opti
    Some(block)
 }
-fn has_new_fn(imp: &ast::ImplDef) -> bool {
+fn has_new_fn(imp: &ast::Impl) -> bool {
-    if let Some(il) = imp.item_list() {
+    if let Some(il) = imp.assoc_item_list() {
        for item in il.assoc_items() {
-            if let ast::AssocItem::FnDef(f) = item {
+            if let ast::AssocItem::Fn(f) = item {
                if let Some(name) = f.name() {
                    if name.text().eq_ignore_ascii_case("new") {
                        return true;
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 967593031..fbaf3c06b 100644
--- a/crates/ra_assists/src/handlers/introduce_named_lifetime.rs
+++ b/crates/ra_assists/src/handlers/introduce_named_lifetime.rs
@@ -1,5 +1,5 @@
 use ra_syntax::{
-    ast::{self, NameOwner, TypeAscriptionOwner, TypeParamsOwner},
+    ast::{self, GenericParamsOwner, NameOwner},
    AstNode, SyntaxKind, TextRange, TextSize,
 };
 use rustc_hash::FxHashSet;
@@ -38,9 +38,9 @@ pub(crate) fn introduce_named_lifetime(acc: &mut Assists, ctx: &AssistContext) -
    let lifetime_token = ctx
        .find_token_at_offset(SyntaxKind::LIFETIME)
        .filter(|lifetime| lifetime.text() == "'_")?;
-    if let Some(fn_def) = lifetime_token.ancestors().find_map(ast::FnDef::cast) {
+    if let Some(fn_def) = lifetime_token.ancestors().find_map(ast::Fn::cast) {
        generate_fn_def_assist(acc, &fn_def, lifetime_token.text_range())
-    } else if let Some(impl_def) = lifetime_token.ancestors().find_map(ast::ImplDef::cast) {
+    } else if let Some(impl_def) = lifetime_token.ancestors().find_map(ast::Impl::cast) {
        generate_impl_def_assist(acc, &impl_def, lifetime_token.text_range())
    } else {
        None
@@ -50,11 +50,11 @@ pub(crate) fn introduce_named_lifetime(acc: &mut Assists, ctx: &AssistContext) -
 /// Generate the assist for the fn def case
 fn generate_fn_def_assist(
    acc: &mut Assists,
-    fn_def: &ast::FnDef,
+    fn_def: &ast::Fn,
    lifetime_loc: TextRange,
 ) -> Option<()> {
    let param_list: ast::ParamList = fn_def.param_list()?;
-    let new_lifetime_param = generate_unique_lifetime_param_name(&fn_def.type_param_list())?;
+    let new_lifetime_param = generate_unique_lifetime_param_name(&fn_def.generic_param_list())?;
    let end_of_fn_ident = fn_def.name()?.ident_token()?.text_range().end();
    let self_param =
        // use the self if it's a reference and has no explicit lifetime
@@ -67,8 +67,8 @@ fn generate_fn_def_assist(
        // otherwise, if there's a single reference parameter without a named liftime, use that
        let fn_params_without_lifetime: Vec<_> = param_list
            .params()
-            .filter_map(|param| match param.ascribed_type() {
+            .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())
@@ -93,10 +93,10 @@ fn generate_fn_def_assist(
 /// Generate the assist for the impl def case
 fn generate_impl_def_assist(
    acc: &mut Assists,
-    impl_def: &ast::ImplDef,
+    impl_def: &ast::Impl,
    lifetime_loc: TextRange,
 ) -> Option<()> {
-    let new_lifetime_param = generate_unique_lifetime_param_name(&impl_def.type_param_list())?;
+    let new_lifetime_param = generate_unique_lifetime_param_name(&impl_def.generic_param_list())?;
    let end_of_impl_kw = impl_def.impl_token()?.text_range().end();
    acc.add(AssistId(ASSIST_NAME, AssistKind::Refactor), ASSIST_LABEL, lifetime_loc, |builder| {
        add_lifetime_param(impl_def, builder, end_of_impl_kw, new_lifetime_param);
@@ -107,7 +107,7 @@ fn generate_impl_def_assist(
 /// Given a type parameter list, generate a unique lifetime parameter name
 /// which is not in the list
 fn generate_unique_lifetime_param_name(
-    existing_type_param_list: &Option<ast::TypeParamList>,
+    existing_type_param_list: &Option<ast::GenericParamList>,
 ) -> Option<char> {
    match existing_type_param_list {
        Some(type_params) => {
@@ -123,13 +123,13 @@ fn generate_unique_lifetime_param_name(
 /// Add the lifetime param to `builder`. If there are type parameters in `type_params_owner`, add it to the end. Otherwise
 /// add new type params brackets with the lifetime parameter at `new_type_params_loc`.
-fn add_lifetime_param<TypeParamsOwner: ast::TypeParamsOwner>(
+fn add_lifetime_param<TypeParamsOwner: ast::GenericParamsOwner>(
    type_params_owner: &TypeParamsOwner,
    builder: &mut AssistBuilder,
    new_type_params_loc: TextSize,
    new_lifetime_param: char,
 ) {
-    match type_params_owner.type_param_list() {
+    match type_params_owner.generic_param_list() {
        // add the new lifetime parameter to an existing type param list
        Some(type_params) => {
            builder.insert(
diff --git a/crates/ra_assists/src/handlers/merge_imports.rs b/crates/ra_assists/src/handlers/merge_imports.rs
index 1beccb61c..c775fe25c 100644
--- a/crates/ra_assists/src/handlers/merge_imports.rs
+++ b/crates/ra_assists/src/handlers/merge_imports.rs
@@ -28,7 +28,7 @@ pub(crate) fn merge_imports(acc: &mut Assists, ctx: &AssistContext) -> Option<()
    let mut rewriter = SyntaxRewriter::default();
    let mut offset = ctx.offset();
-    if let Some(use_item) = tree.syntax().parent().and_then(ast::UseItem::cast) {
+    if let Some(use_item) = tree.syntax().parent().and_then(ast::Use::cast) {
        let (merged, to_delete) = next_prev()
            .filter_map(|dir| neighbor(&use_item, dir))
            .filter_map(|it| Some((it.clone(), it.use_tree()?)))
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/move_bounds.rs b/crates/ra_assists/src/handlers/move_bounds.rs
index ba3dafb99..6d394443e 100644
--- a/crates/ra_assists/src/handlers/move_bounds.rs
+++ b/crates/ra_assists/src/handlers/move_bounds.rs
@@ -23,7 +23,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // }
 // ```
 pub(crate) fn move_bounds_to_where_clause(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let type_param_list = ctx.find_node_at_offset::<ast::TypeParamList>()?;
+    let type_param_list = ctx.find_node_at_offset::<ast::GenericParamList>()?;
    let mut type_params = type_param_list.type_params();
    if type_params.all(|p| p.type_bound_list().is_none()) {
@@ -37,13 +37,13 @@ pub(crate) fn move_bounds_to_where_clause(acc: &mut Assists, ctx: &AssistContext
    let anchor = match_ast! {
        match parent {
-            ast::FnDef(it) => it.body()?.syntax().clone().into(),
+            ast::Fn(it) => it.body()?.syntax().clone().into(),
-            ast::TraitDef(it) => it.item_list()?.syntax().clone().into(),
+            ast::Trait(it) => it.assoc_item_list()?.syntax().clone().into(),
-            ast::ImplDef(it) => it.item_list()?.syntax().clone().into(),
+            ast::Impl(it) => it.assoc_item_list()?.syntax().clone().into(),
-            ast::EnumDef(it) => it.variant_list()?.syntax().clone().into(),
+            ast::Enum(it) => it.variant_list()?.syntax().clone().into(),
-            ast::StructDef(it) => {
+            ast::Struct(it) => {
                it.syntax().children_with_tokens()
-                    .find(|it| it.kind() == RECORD_FIELD_DEF_LIST || it.kind() == T![;])?
+                    .find(|it| it.kind() == RECORD_FIELD_LIST || it.kind() == T![;])?
            },
            _ => return None
        }
diff --git a/crates/ra_assists/src/handlers/raw_string.rs b/crates/ra_assists/src/handlers/raw_string.rs
index 4e8a0c2db..4c797178f 100644
--- a/crates/ra_assists/src/handlers/raw_string.rs
+++ b/crates/ra_assists/src/handlers/raw_string.rs
@@ -173,7 +173,7 @@ fn test_required_hashes() {
 }
 #[cfg(test)]
-mod test {
+mod tests {
    use test_utils::mark;
    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
diff --git a/crates/ra_assists/src/handlers/remove_dbg.rs b/crates/ra_assists/src/handlers/remove_dbg.rs
index a616cca57..9430ce1b5 100644
--- a/crates/ra_assists/src/handlers/remove_dbg.rs
+++ b/crates/ra_assists/src/handlers/remove_dbg.rs
@@ -1,6 +1,6 @@
 use ra_syntax::{
    ast::{self, AstNode},
-    TextSize, T,
+    TextRange, TextSize, T,
 };
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -27,19 +27,33 @@ pub(crate) fn remove_dbg(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
        return None;
    }
-    let macro_range = macro_call.syntax().text_range();
+    let is_leaf = macro_call.syntax().next_sibling().is_none();
-    let macro_content = {
+    let macro_end = if macro_call.semicolon_token().is_some() {
-        let macro_args = macro_call.token_tree()?.syntax().clone();
+        macro_call.syntax().text_range().end() - TextSize::of(';')
+    } else {
+        macro_call.syntax().text_range().end()
+    };
-        let text = macro_args.text();
+    // macro_range determines what will be deleted and replaced with macro_content
-        let without_parens = TextSize::of('(')..text.len() - TextSize::of(')');
+    let macro_range = TextRange::new(macro_call.syntax().text_range().start(), macro_end);
-        text.slice(without_parens).to_string()
+    let paste_instead_of_dbg = {
+        let text = macro_call.token_tree()?.syntax().text();
+        // leafiness determines if we should include the parenthesis or not
+        let slice_index: TextRange = if is_leaf {
+            // leaf means - we can extract the contents of the dbg! in text
+            TextRange::new(TextSize::of('('), text.len() - TextSize::of(')'))
+        } else {
+            // not leaf - means we should keep the parens
+            TextRange::up_to(text.len())
+        };
+        text.slice(slice_index).to_string()
    };
    let target = macro_call.syntax().text_range();
    acc.add(AssistId("remove_dbg", AssistKind::Refactor), "Remove dbg!()", target, |builder| {
-        builder.replace(macro_range, macro_content);
+        builder.replace(macro_range, paste_instead_of_dbg);
    })
 }
@@ -99,6 +113,7 @@ fn foo(n: usize) {
 ",
        );
    }
    #[test]
    fn test_remove_dbg_with_brackets_and_braces() {
        check_assist(remove_dbg, "dbg![<|>1 + 1]", "1 + 1");
@@ -113,7 +128,7 @@ fn foo(n: usize) {
    }
    #[test]
-    fn remove_dbg_target() {
+    fn test_remove_dbg_target() {
        check_assist_target(
            remove_dbg,
            "
@@ -126,4 +141,65 @@ fn foo(n: usize) {
            "dbg!(n.checked_sub(4))",
        );
    }
+    #[test]
+    fn test_remove_dbg_keep_semicolon() {
+        // https://github.com/rust-analyzer/rust-analyzer/issues/5129#issuecomment-651399779
+        // not quite though
+        // adding a comment at the end of the line makes
+        // the ast::MacroCall to include the semicolon at the end
+        check_assist(
+            remove_dbg,
+            r#"let res = <|>dbg!(1 * 20); // needless comment"#,
+            r#"let res = 1 * 20; // needless comment"#,
+        );
+    }
+    #[test]
+    fn test_remove_dbg_keep_expression() {
+        check_assist(
+            remove_dbg,
+            r#"let res = <|>dbg!(a + b).foo();"#,
+            r#"let res = (a + b).foo();"#,
+        );
+    }
+    #[test]
+    fn test_remove_dbg_from_inside_fn() {
+        check_assist_target(
+            remove_dbg,
+            r#"
+fn square(x: u32) -> u32 {
+    x * x
+}
+fn main() {
+    let x = square(dbg<|>!(5 + 10));
+    println!("{}", x);
+}"#,
+            "dbg!(5 + 10)",
+        );
+        check_assist(
+            remove_dbg,
+            r#"
+fn square(x: u32) -> u32 {
+    x * x
+}
+fn main() {
+    let x = square(dbg<|>!(5 + 10));
+    println!("{}", x);
+}"#,
+            r#"
+fn square(x: u32) -> u32 {
+    x * x
+}
+fn main() {
+    let x = square(5 + 10);
+    println!("{}", x);
+}"#,
+        );
+    }
 }
diff --git a/crates/ra_assists/src/handlers/reorder_fields.rs b/crates/ra_assists/src/handlers/reorder_fields.rs
index 2ac1c56cf..c9b743a06 100644
--- a/crates/ra_assists/src/handlers/reorder_fields.rs
+++ b/crates/ra_assists/src/handlers/reorder_fields.rs
@@ -23,7 +23,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // ```
 //
 pub(crate) fn reorder_fields(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    reorder::<ast::RecordLit>(acc, ctx).or_else(|| reorder::<ast::RecordPat>(acc, ctx))
+    reorder::<ast::RecordExpr>(acc, ctx).or_else(|| reorder::<ast::RecordPat>(acc, ctx))
 }
 fn reorder<R: AstNode>(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
@@ -56,8 +56,8 @@ fn reorder<R: AstNode>(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
 fn get_fields_kind(node: &SyntaxNode) -> Vec<SyntaxKind> {
    match node.kind() {
-        RECORD_LIT => vec![RECORD_FIELD],
+        RECORD_EXPR => vec![RECORD_EXPR_FIELD],
-        RECORD_PAT => vec![RECORD_FIELD_PAT, BIND_PAT],
+        RECORD_PAT => vec![RECORD_PAT_FIELD, IDENT_PAT],
        _ => vec![],
    }
 }
@@ -65,8 +65,8 @@ fn get_fields_kind(node: &SyntaxNode) -> Vec<SyntaxKind> {
 fn get_field_name(node: &SyntaxNode) -> String {
    let res = match_ast! {
        match node {
-            ast::RecordField(field) => field.field_name().map(|it| it.to_string()),
+            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_if_let_with_match.rs b/crates/ra_assists/src/handlers/replace_if_let_with_match.rs
index b7e30a7f2..ecafb74a1 100644
--- a/crates/ra_assists/src/handlers/replace_if_let_with_match.rs
+++ b/crates/ra_assists/src/handlers/replace_if_let_with_match.rs
@@ -65,7 +65,7 @@ pub(crate) fn replace_if_let_with_match(acc: &mut Assists, ctx: &AssistContext)
                        .type_of_pat(&pat)
                        .and_then(|ty| TryEnum::from_ty(&ctx.sema, &ty))
                        .map(|it| it.sad_pattern())
-                        .unwrap_or_else(|| make::placeholder_pat().into());
+                        .unwrap_or_else(|| make::wildcard_pat().into());
                    let else_expr = unwrap_trivial_block(else_block);
                    make::match_arm(vec![pattern], else_expr)
                };
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..e4d436dec 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
@@ -50,10 +50,10 @@ pub(crate) fn replace_let_with_if_let(acc: &mut Assists, ctx: &AssistContext) ->
        target,
        |edit| {
            let with_placeholder: ast::Pat = match happy_variant {
-                None => make::placeholder_pat().into(),
+                None => make::wildcard_pat().into(),
                Some(var_name) => make::tuple_struct_pat(
                    make::path_unqualified(make::path_segment(make::name_ref(var_name))),
-                    once(make::placeholder_pat().into()),
+                    once(make::wildcard_pat().into()),
                )
                .into(),
            };
@@ -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 =
+            let placeholder = stmt.syntax().descendants().find_map(ast::WildcardPat::cast).unwrap();
-                stmt.syntax().descendants().find_map(ast::PlaceholderPat::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/handlers/replace_qualified_name_with_use.rs b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
index 3d51faa54..da0a860c5 100644
--- a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
@@ -25,7 +25,7 @@ pub(crate) fn replace_qualified_name_with_use(
 ) -> Option<()> {
    let path: ast::Path = ctx.find_node_at_offset()?;
    // We don't want to mess with use statements
-    if path.syntax().ancestors().find_map(ast::UseItem::cast).is_some() {
+    if path.syntax().ancestors().find_map(ast::Use::cast).is_some() {
        return None;
    }
@@ -85,7 +85,7 @@ fn shorten_paths(rewriter: &mut SyntaxRewriter<'static>, node: SyntaxNode, path:
            match child {
                // Don't modify `use` items, as this can break the `use` item when injecting a new
                // import into the use tree.
-                ast::UseItem(_it) => continue,
+                ast::Use(_it) => continue,
                // Don't descend into submodules, they don't have the same `use` items in scope.
                ast::Module(_it) => continue,
@@ -643,4 +643,46 @@ fn main() {
    ",
        );
    }
+    #[test]
+    fn does_not_replace_pub_use() {
+        check_assist(
+            replace_qualified_name_with_use,
+            r"
+pub use std::fmt;
+impl std::io<|> for Foo {
+}
+    ",
+            r"
+use std::io;
+pub use std::fmt;
+impl io for Foo {
+}
+    ",
+        );
+    }
+    #[test]
+    fn does_not_replace_pub_crate_use() {
+        check_assist(
+            replace_qualified_name_with_use,
+            r"
+pub(crate) use std::fmt;
+impl std::io<|> for Foo {
+}
+    ",
+            r"
+use std::io;
+pub(crate) use std::fmt;
+impl io for Foo {
+}
+    ",
+        );
+    }
 }
diff --git a/crates/ra_assists/src/handlers/replace_unwrap_with_match.rs b/crates/ra_assists/src/handlers/replace_unwrap_with_match.rs
index e5a4bb23c..d69f2c1b0 100644
--- a/crates/ra_assists/src/handlers/replace_unwrap_with_match.rs
+++ b/crates/ra_assists/src/handlers/replace_unwrap_with_match.rs
@@ -52,7 +52,7 @@ pub(crate) fn replace_unwrap_with_match(acc: &mut Assists, ctx: &AssistContext)
        target,
        |builder| {
            let ok_path = make::path_unqualified(make::path_segment(make::name_ref(happy_variant)));
-            let it = make::bind_pat(make::name("a")).into();
+            let it = make::ident_pat(make::name("a")).into();
            let ok_tuple = make::tuple_struct_pat(ok_path, iter::once(it)).into();
            let bind_path = make::path_unqualified(make::path_segment(make::name_ref("a")));
@@ -60,7 +60,7 @@ pub(crate) fn replace_unwrap_with_match(acc: &mut Assists, ctx: &AssistContext)
            let unreachable_call = make::expr_unreachable();
            let err_arm =
-                make::match_arm(iter::once(make::placeholder_pat().into()), unreachable_call);
+                make::match_arm(iter::once(make::wildcard_pat().into()), unreachable_call);
            let match_arm_list = make::match_arm_list(vec![ok_arm, err_arm]);
            let match_expr = make::expr_match(caller.clone(), match_arm_list)
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 465b90415..507646cc8 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -140,6 +140,7 @@ mod handlers {
    mod change_return_type_to_result;
    mod change_visibility;
    mod early_return;
+    mod expand_glob_import;
    mod extract_struct_from_enum_variant;
    mod extract_variable;
    mod fill_match_arms;
@@ -181,6 +182,7 @@ mod handlers {
            change_return_type_to_result::change_return_type_to_result,
            change_visibility::change_visibility,
            early_return::convert_to_guarded_return,
+            expand_glob_import::expand_glob_import,
            extract_struct_from_enum_variant::extract_struct_from_enum_variant,
            extract_variable::extract_variable,
            fill_match_arms::fill_match_arms,
diff --git a/crates/ra_assists/src/tests/generated.rs b/crates/ra_assists/src/tests/generated.rs
index eff7feded..97978e7a2 100644
--- a/crates/ra_assists/src/tests/generated.rs
+++ b/crates/ra_assists/src/tests/generated.rs
@@ -229,6 +229,33 @@ fn main() {
 }
 #[test]
+fn doctest_expand_glob_import() {
+    check_doc_test(
+        "expand_glob_import",
+        r#####"
+mod foo {
+    pub struct Bar;
+    pub struct Baz;
+}
+use foo::*<|>;
+fn qux(bar: Bar, baz: Baz) {}
+"#####,
+        r#####"
+mod foo {
+    pub struct Bar;
+    pub struct Baz;
+}
+use foo::{Baz, Bar};
+fn qux(bar: Bar, baz: Baz) {}
+"#####,
+    )
+}
+#[test]
 fn doctest_extract_struct_from_enum_variant() {
    check_doc_test(
        "extract_struct_from_enum_variant",
diff --git a/crates/ra_assists/src/utils.rs b/crates/ra_assists/src/utils.rs
index 02de902d6..54d5678d1 100644
--- a/crates/ra_assists/src/utils.rs
+++ b/crates/ra_assists/src/utils.rs
@@ -56,33 +56,34 @@ pub(crate) fn render_snippet(_cap: SnippetCap, node: &SyntaxNode, cursor: Cursor
 pub fn get_missing_assoc_items(
    sema: &Semantics<RootDatabase>,
-    impl_def: &ast::ImplDef,
+    impl_def: &ast::Impl,
 ) -> Vec<hir::AssocItem> {
    // Names must be unique between constants and functions. However, type aliases
    // may share the same name as a function or constant.
    let mut impl_fns_consts = FxHashSet::default();
    let mut impl_type = FxHashSet::default();
-    if let Some(item_list) = impl_def.item_list() {
+    if let Some(item_list) = impl_def.assoc_item_list() {
        for item in item_list.assoc_items() {
            match item {
-                ast::AssocItem::FnDef(f) => {
+                ast::AssocItem::Fn(f) => {
                    if let Some(n) = f.name() {
                        impl_fns_consts.insert(n.syntax().to_string());
                    }
                }
-                ast::AssocItem::TypeAliasDef(t) => {
+                ast::AssocItem::TypeAlias(t) => {
                    if let Some(n) = t.name() {
                        impl_type.insert(n.syntax().to_string());
                    }
                }
-                ast::AssocItem::ConstDef(c) => {
+                ast::AssocItem::Const(c) => {
                    if let Some(n) = c.name() {
                        impl_fns_consts.insert(n.syntax().to_string());
                    }
                }
+                ast::AssocItem::MacroCall(_) => (),
            }
        }
    }
@@ -108,13 +109,10 @@ pub fn get_missing_assoc_items(
 pub(crate) fn resolve_target_trait(
    sema: &Semantics<RootDatabase>,
-    impl_def: &ast::ImplDef,
+    impl_def: &ast::Impl,
 ) -> Option<hir::Trait> {
-    let ast_path = impl_def
+    let ast_path =
-        .target_trait()
+        impl_def.trait_().map(|it| it.syntax().clone()).and_then(ast::PathType::cast)?.path()?;
-        .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),
@@ -183,10 +181,10 @@ impl TryEnum {
        match self {
            TryEnum::Result => make::tuple_struct_pat(
                make::path_unqualified(make::path_segment(make::name_ref("Err"))),
-                iter::once(make::placeholder_pat().into()),
+                iter::once(make::wildcard_pat().into()),
            )
            .into(),
-            TryEnum::Option => make::bind_pat(make::name("None")).into(),
+            TryEnum::Option => make::ident_pat(make::name("None")).into(),
        }
    }
diff --git a/crates/ra_assists/src/utils/insert_use.rs b/crates/ra_assists/src/utils/insert_use.rs
index 8c4f33e59..32780fceb 100644
--- a/crates/ra_assists/src/utils/insert_use.rs
+++ b/crates/ra_assists/src/utils/insert_use.rs
@@ -4,7 +4,7 @@
 use hir::{self, ModPath};
 use ra_syntax::{
-    ast::{self, NameOwner},
+    ast::{self, NameOwner, VisibilityOwner},
    AstNode, Direction, SmolStr,
    SyntaxKind::{PATH, PATH_SEGMENT},
    SyntaxNode, T,
@@ -215,7 +215,7 @@ fn walk_use_tree_for_best_action(
    let prev_len = current_path_segments.len();
    let tree_list = current_use_tree.use_tree_list();
-    let alias = current_use_tree.alias();
+    let alias = current_use_tree.rename();
    let path = match current_use_tree.path() {
        Some(path) => path,
@@ -225,7 +225,7 @@ fn walk_use_tree_for_best_action(
                current_use_tree
                    .syntax()
                    .ancestors()
-                    .find_map(ast::UseItem::cast)
+                    .find_map(ast::Use::cast)
                    .map(|it| it.syntax().clone()),
                true,
            );
@@ -254,7 +254,7 @@ fn walk_use_tree_for_best_action(
            current_use_tree
                .syntax()
                .ancestors()
-                .find_map(ast::UseItem::cast)
+                .find_map(ast::Use::cast)
                .map(|it| it.syntax().clone()),
            true,
        ),
@@ -304,7 +304,7 @@ fn walk_use_tree_for_best_action(
                current_use_tree
                    .syntax()
                    .ancestors()
-                    .find_map(ast::UseItem::cast)
+                    .find_map(ast::Use::cast)
                    .map(|it| it.syntax().clone()),
                true,
            );
@@ -377,7 +377,8 @@ fn best_action_for_target(
    let mut storage = Vec::with_capacity(16); // this should be the only allocation
    let best_action = container
        .children()
-        .filter_map(ast::UseItem::cast)
+        .filter_map(ast::Use::cast)
+        .filter(|u| u.visibility().is_none())
        .filter_map(|it| it.use_tree())
        .map(|u| walk_use_tree_for_best_action(&mut storage, None, u, target))
        .fold(None, |best, a| match best {
diff --git a/crates/ra_db/Cargo.toml b/crates/ra_db/Cargo.toml
index 5f334d04f..fe73dc015 100644
--- a/crates/ra_db/Cargo.toml
+++ b/crates/ra_db/Cargo.toml
@@ -9,7 +9,7 @@ license = "MIT OR Apache-2.0"
 doctest = false
 [dependencies]
-salsa = "0.15.0"
+salsa = "0.15.2"
 rustc-hash = "1.1.0"
 ra_syntax = { path = "../ra_syntax" }
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 859bdfb3b..27cdabea0 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -361,8 +361,8 @@ pub struct Field {
 #[derive(Debug, PartialEq, Eq)]
 pub enum FieldSource {
-    Named(ast::RecordFieldDef),
+    Named(ast::RecordField),
-    Pos(ast::TupleFieldDef),
+    Pos(ast::TupleField),
 }
 impl Field {
@@ -1002,7 +1002,7 @@ impl Local {
        Type::new(db, krate, def, ty)
    }
-    pub fn source(self, db: &dyn HirDatabase) -> InFile<Either<ast::BindPat, ast::SelfParam>> {
+    pub fn source(self, db: &dyn HirDatabase) -> InFile<Either<ast::IdentPat, ast::SelfParam>> {
        let (_body, source_map) = db.body_with_source_map(self.parent.into());
        let src = source_map.pat_syntax(self.pat_id).unwrap(); // Hmm...
        let root = src.file_syntax(db.upcast());
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index a2b9f3e35..07333c453 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -13,14 +13,7 @@ pub use hir_expand::db::{
    AstDatabase, AstDatabaseStorage, AstIdMapQuery, InternEagerExpansionQuery, InternMacroQuery,
    MacroArgTextQuery, MacroDefQuery, MacroExpandQuery, ParseMacroQuery,
 };
-pub use hir_ty::db::{
+pub use hir_ty::db::*;
-    AssociatedTyDataQuery, AssociatedTyValueQuery, CallableItemSignatureQuery, FieldTypesQuery,
-    GenericDefaultsQuery, GenericPredicatesForParamQuery, GenericPredicatesQuery, HirDatabase,
-    HirDatabaseStorage, ImplDatumQuery, ImplSelfTyQuery, ImplTraitQuery, InferQueryQuery,
-    InherentImplsInCrateQuery, InternTypeParamIdQuery, ReturnTypeImplTraitsQuery, StructDatumQuery,
-    TraitDatumQuery, TraitImplsInCrateQuery, TraitImplsInDepsQuery, TraitSolveQuery, TyQuery,
-    ValueTyQuery,
-};
 #[test]
 fn hir_database_is_object_safe() {
diff --git a/crates/ra_hir/src/has_source.rs b/crates/ra_hir/src/has_source.rs
index 4fd675039..db9228d67 100644
--- a/crates/ra_hir/src/has_source.rs
+++ b/crates/ra_hir/src/has_source.rs
@@ -57,56 +57,56 @@ impl HasSource for Field {
    }
 }
 impl HasSource for Struct {
-    type Ast = ast::StructDef;
+    type Ast = ast::Struct;
-    fn source(self, db: &dyn HirDatabase) -> InFile<ast::StructDef> {
+    fn source(self, db: &dyn HirDatabase) -> InFile<ast::Struct> {
        self.id.lookup(db.upcast()).source(db.upcast())
    }
 }
 impl HasSource for Union {
-    type Ast = ast::UnionDef;
+    type Ast = ast::Union;
-    fn source(self, db: &dyn HirDatabase) -> InFile<ast::UnionDef> {
+    fn source(self, db: &dyn HirDatabase) -> InFile<ast::Union> {
        self.id.lookup(db.upcast()).source(db.upcast())
    }
 }
 impl HasSource for Enum {
-    type Ast = ast::EnumDef;
+    type Ast = ast::Enum;
-    fn source(self, db: &dyn HirDatabase) -> InFile<ast::EnumDef> {
+    fn source(self, db: &dyn HirDatabase) -> InFile<ast::Enum> {
        self.id.lookup(db.upcast()).source(db.upcast())
    }
 }
 impl HasSource for EnumVariant {
-    type Ast = ast::EnumVariant;
+    type Ast = ast::Variant;
-    fn source(self, db: &dyn HirDatabase) -> InFile<ast::EnumVariant> {
+    fn source(self, db: &dyn HirDatabase) -> InFile<ast::Variant> {
        self.parent.id.child_source(db.upcast()).map(|map| map[self.id].clone())
    }
 }
 impl HasSource for Function {
-    type Ast = ast::FnDef;
+    type Ast = ast::Fn;
-    fn source(self, db: &dyn HirDatabase) -> InFile<ast::FnDef> {
+    fn source(self, db: &dyn HirDatabase) -> InFile<ast::Fn> {
        self.id.lookup(db.upcast()).source(db.upcast())
    }
 }
 impl HasSource for Const {
-    type Ast = ast::ConstDef;
+    type Ast = ast::Const;
-    fn source(self, db: &dyn HirDatabase) -> InFile<ast::ConstDef> {
+    fn source(self, db: &dyn HirDatabase) -> InFile<ast::Const> {
        self.id.lookup(db.upcast()).source(db.upcast())
    }
 }
 impl HasSource for Static {
-    type Ast = ast::StaticDef;
+    type Ast = ast::Static;
-    fn source(self, db: &dyn HirDatabase) -> InFile<ast::StaticDef> {
+    fn source(self, db: &dyn HirDatabase) -> InFile<ast::Static> {
        self.id.lookup(db.upcast()).source(db.upcast())
    }
 }
 impl HasSource for Trait {
-    type Ast = ast::TraitDef;
+    type Ast = ast::Trait;
-    fn source(self, db: &dyn HirDatabase) -> InFile<ast::TraitDef> {
+    fn source(self, db: &dyn HirDatabase) -> InFile<ast::Trait> {
        self.id.lookup(db.upcast()).source(db.upcast())
    }
 }
 impl HasSource for TypeAlias {
-    type Ast = ast::TypeAliasDef;
+    type Ast = ast::TypeAlias;
-    fn source(self, db: &dyn HirDatabase) -> InFile<ast::TypeAliasDef> {
+    fn source(self, db: &dyn HirDatabase) -> InFile<ast::TypeAlias> {
        self.id.lookup(db.upcast()).source(db.upcast())
    }
 }
@@ -120,14 +120,14 @@ impl HasSource for MacroDef {
    }
 }
 impl HasSource for ImplDef {
-    type Ast = ast::ImplDef;
+    type Ast = ast::Impl;
-    fn source(self, db: &dyn HirDatabase) -> InFile<ast::ImplDef> {
+    fn source(self, db: &dyn HirDatabase) -> InFile<ast::Impl> {
        self.id.lookup(db.upcast()).source(db.upcast())
    }
 }
 impl HasSource for TypeParam {
-    type Ast = Either<ast::TraitDef, ast::TypeParam>;
+    type Ast = Either<ast::Trait, ast::TypeParam>;
    fn source(self, db: &dyn HirDatabase) -> InFile<Self::Ast> {
        let child_source = self.id.parent.child_source(db.upcast());
        child_source.map(|it| it[self.id.local_id].clone())
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index 1436b1afe..307b336f2 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -209,11 +209,14 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        self.imp.resolve_field(field)
    }
-    pub fn resolve_record_field(&self, field: &ast::RecordField) -> Option<(Field, Option<Local>)> {
+    pub fn resolve_record_field(
+        &self,
+        field: &ast::RecordExprField,
+    ) -> Option<(Field, Option<Local>)> {
        self.imp.resolve_record_field(field)
    }
-    pub fn resolve_record_field_pat(&self, field: &ast::RecordFieldPat) -> Option<Field> {
+    pub fn resolve_record_field_pat(&self, field: &ast::RecordPatField) -> Option<Field> {
        self.imp.resolve_record_field_pat(field)
    }
@@ -225,7 +228,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        self.imp.resolve_path(path)
    }
-    pub fn resolve_variant(&self, record_lit: ast::RecordLit) -> Option<VariantDef> {
+    pub fn resolve_variant(&self, record_lit: ast::RecordExpr) -> Option<VariantDef> {
        self.imp.resolve_variant(record_lit).map(VariantDef::from)
    }
@@ -233,14 +236,14 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        self.imp.lower_path(path)
    }
-    pub fn resolve_bind_pat_to_const(&self, pat: &ast::BindPat) -> Option<ModuleDef> {
+    pub fn resolve_bind_pat_to_const(&self, pat: &ast::IdentPat) -> Option<ModuleDef> {
        self.imp.resolve_bind_pat_to_const(pat)
    }
    // FIXME: use this instead?
    // pub fn resolve_name_ref(&self, name_ref: &ast::NameRef) -> Option<???>;
-    pub fn record_literal_missing_fields(&self, literal: &ast::RecordLit) -> Vec<(Field, Type)> {
+    pub fn record_literal_missing_fields(&self, literal: &ast::RecordExpr) -> Vec<(Field, Type)> {
        self.imp.record_literal_missing_fields(literal)
    }
@@ -422,11 +425,11 @@ impl<'db> SemanticsImpl<'db> {
        self.analyze(field.syntax()).resolve_field(self.db, field)
    }
-    fn resolve_record_field(&self, field: &ast::RecordField) -> Option<(Field, Option<Local>)> {
+    fn resolve_record_field(&self, field: &ast::RecordExprField) -> Option<(Field, Option<Local>)> {
        self.analyze(field.syntax()).resolve_record_field(self.db, field)
    }
-    fn resolve_record_field_pat(&self, field: &ast::RecordFieldPat) -> Option<Field> {
+    fn resolve_record_field_pat(&self, field: &ast::RecordPatField) -> Option<Field> {
        self.analyze(field.syntax()).resolve_record_field_pat(self.db, field)
    }
@@ -440,7 +443,7 @@ impl<'db> SemanticsImpl<'db> {
        self.analyze(path.syntax()).resolve_path(self.db, path)
    }
-    fn resolve_variant(&self, record_lit: ast::RecordLit) -> Option<VariantId> {
+    fn resolve_variant(&self, record_lit: ast::RecordExpr) -> Option<VariantId> {
        self.analyze(record_lit.syntax()).resolve_variant(self.db, record_lit)
    }
@@ -449,11 +452,11 @@ impl<'db> SemanticsImpl<'db> {
        Path::from_src(path.clone(), &Hygiene::new(self.db.upcast(), src.file_id.into()))
    }
-    fn resolve_bind_pat_to_const(&self, pat: &ast::BindPat) -> Option<ModuleDef> {
+    fn resolve_bind_pat_to_const(&self, pat: &ast::IdentPat) -> Option<ModuleDef> {
        self.analyze(pat.syntax()).resolve_bind_pat_to_const(self.db, pat)
    }
-    fn record_literal_missing_fields(&self, literal: &ast::RecordLit) -> Vec<(Field, Type)> {
+    fn record_literal_missing_fields(&self, literal: &ast::RecordExpr) -> Vec<(Field, Type)> {
        self.analyze(literal.syntax())
            .record_literal_missing_fields(self.db, literal)
            .unwrap_or_default()
@@ -577,21 +580,21 @@ macro_rules! to_def_impls {
 to_def_impls![
    (crate::Module, ast::Module, module_to_def),
-    (crate::Struct, ast::StructDef, struct_to_def),
+    (crate::Struct, ast::Struct, struct_to_def),
-    (crate::Enum, ast::EnumDef, enum_to_def),
+    (crate::Enum, ast::Enum, enum_to_def),
-    (crate::Union, ast::UnionDef, union_to_def),
+    (crate::Union, ast::Union, union_to_def),
-    (crate::Trait, ast::TraitDef, trait_to_def),
+    (crate::Trait, ast::Trait, trait_to_def),
-    (crate::ImplDef, ast::ImplDef, impl_to_def),
+    (crate::ImplDef, ast::Impl, impl_to_def),
-    (crate::TypeAlias, ast::TypeAliasDef, type_alias_to_def),
+    (crate::TypeAlias, ast::TypeAlias, type_alias_to_def),
-    (crate::Const, ast::ConstDef, const_to_def),
+    (crate::Const, ast::Const, const_to_def),
-    (crate::Static, ast::StaticDef, static_to_def),
+    (crate::Static, ast::Static, static_to_def),
-    (crate::Function, ast::FnDef, fn_to_def),
+    (crate::Function, ast::Fn, fn_to_def),
-    (crate::Field, ast::RecordFieldDef, record_field_to_def),
+    (crate::Field, ast::RecordField, record_field_to_def),
-    (crate::Field, ast::TupleFieldDef, tuple_field_to_def),
+    (crate::Field, ast::TupleField, tuple_field_to_def),
-    (crate::EnumVariant, ast::EnumVariant, enum_variant_to_def),
+    (crate::EnumVariant, ast::Variant, enum_variant_to_def),
    (crate::TypeParam, ast::TypeParam, type_param_to_def),
    (crate::MacroDef, ast::MacroCall, macro_call_to_def), // this one is dubious, not all calls are macros
-    (crate::Local, ast::BindPat, bind_pat_to_def),
+    (crate::Local, ast::IdentPat, bind_pat_to_def),
 ];
 fn find_root(node: &SyntaxNode) -> SyntaxNode {
diff --git a/crates/ra_hir/src/semantics/source_to_def.rs b/crates/ra_hir/src/semantics/source_to_def.rs
index 42e5a1bdb..863e8e5ff 100644
--- a/crates/ra_hir/src/semantics/source_to_def.rs
+++ b/crates/ra_hir/src/semantics/source_to_def.rs
@@ -65,57 +65,48 @@ impl SourceToDefCtx<'_, '_> {
        Some(ModuleId { krate: parent_module.krate, local_id: child_id })
    }
-    pub(super) fn trait_to_def(&mut self, src: InFile<ast::TraitDef>) -> Option<TraitId> {
+    pub(super) fn trait_to_def(&mut self, src: InFile<ast::Trait>) -> Option<TraitId> {
        self.to_def(src, keys::TRAIT)
    }
-    pub(super) fn impl_to_def(&mut self, src: InFile<ast::ImplDef>) -> Option<ImplId> {
+    pub(super) fn impl_to_def(&mut self, src: InFile<ast::Impl>) -> Option<ImplId> {
        self.to_def(src, keys::IMPL)
    }
-    pub(super) fn fn_to_def(&mut self, src: InFile<ast::FnDef>) -> Option<FunctionId> {
+    pub(super) fn fn_to_def(&mut self, src: InFile<ast::Fn>) -> Option<FunctionId> {
        self.to_def(src, keys::FUNCTION)
    }
-    pub(super) fn struct_to_def(&mut self, src: InFile<ast::StructDef>) -> Option<StructId> {
+    pub(super) fn struct_to_def(&mut self, src: InFile<ast::Struct>) -> Option<StructId> {
        self.to_def(src, keys::STRUCT)
    }
-    pub(super) fn enum_to_def(&mut self, src: InFile<ast::EnumDef>) -> Option<EnumId> {
+    pub(super) fn enum_to_def(&mut self, src: InFile<ast::Enum>) -> Option<EnumId> {
        self.to_def(src, keys::ENUM)
    }
-    pub(super) fn union_to_def(&mut self, src: InFile<ast::UnionDef>) -> Option<UnionId> {
+    pub(super) fn union_to_def(&mut self, src: InFile<ast::Union>) -> Option<UnionId> {
        self.to_def(src, keys::UNION)
    }
-    pub(super) fn static_to_def(&mut self, src: InFile<ast::StaticDef>) -> Option<StaticId> {
+    pub(super) fn static_to_def(&mut self, src: InFile<ast::Static>) -> Option<StaticId> {
        self.to_def(src, keys::STATIC)
    }
-    pub(super) fn const_to_def(&mut self, src: InFile<ast::ConstDef>) -> Option<ConstId> {
+    pub(super) fn const_to_def(&mut self, src: InFile<ast::Const>) -> Option<ConstId> {
        self.to_def(src, keys::CONST)
    }
-    pub(super) fn type_alias_to_def(
+    pub(super) fn type_alias_to_def(&mut self, src: InFile<ast::TypeAlias>) -> Option<TypeAliasId> {
-        &mut self,
-        src: InFile<ast::TypeAliasDef>,
-    ) -> Option<TypeAliasId> {
        self.to_def(src, keys::TYPE_ALIAS)
    }
-    pub(super) fn record_field_to_def(
+    pub(super) fn record_field_to_def(&mut self, src: InFile<ast::RecordField>) -> Option<FieldId> {
-        &mut self,
-        src: InFile<ast::RecordFieldDef>,
-    ) -> Option<FieldId> {
        self.to_def(src, keys::RECORD_FIELD)
    }
-    pub(super) fn tuple_field_to_def(
+    pub(super) fn tuple_field_to_def(&mut self, src: InFile<ast::TupleField>) -> Option<FieldId> {
-        &mut self,
-        src: InFile<ast::TupleFieldDef>,
-    ) -> Option<FieldId> {
        self.to_def(src, keys::TUPLE_FIELD)
    }
    pub(super) fn enum_variant_to_def(
        &mut self,
-        src: InFile<ast::EnumVariant>,
+        src: InFile<ast::Variant>,
    ) -> Option<EnumVariantId> {
-        self.to_def(src, keys::ENUM_VARIANT)
+        self.to_def(src, keys::VARIANT)
    }
    pub(super) fn bind_pat_to_def(
        &mut self,
-        src: InFile<ast::BindPat>,
+        src: InFile<ast::IdentPat>,
    ) -> Option<(DefWithBodyId, PatId)> {
        let container = self.find_pat_container(src.as_ref().map(|it| it.syntax()))?;
        let (_body, source_map) = self.db.body_with_source_map(container);
@@ -163,39 +154,39 @@ impl SourceToDefCtx<'_, '_> {
                        let def = self.module_to_def(container.with_value(it))?;
                        def.into()
                    },
-                    ast::TraitDef(it) => {
+                    ast::Trait(it) => {
                        let def = self.trait_to_def(container.with_value(it))?;
                        def.into()
                    },
-                    ast::ImplDef(it) => {
+                    ast::Impl(it) => {
                        let def = self.impl_to_def(container.with_value(it))?;
                        def.into()
                    },
-                    ast::FnDef(it) => {
+                    ast::Fn(it) => {
                        let def = self.fn_to_def(container.with_value(it))?;
                        DefWithBodyId::from(def).into()
                    },
-                    ast::StructDef(it) => {
+                    ast::Struct(it) => {
                        let def = self.struct_to_def(container.with_value(it))?;
                        VariantId::from(def).into()
                    },
-                    ast::EnumDef(it) => {
+                    ast::Enum(it) => {
                        let def = self.enum_to_def(container.with_value(it))?;
                        def.into()
                    },
-                    ast::UnionDef(it) => {
+                    ast::Union(it) => {
                        let def = self.union_to_def(container.with_value(it))?;
                        VariantId::from(def).into()
                    },
-                    ast::StaticDef(it) => {
+                    ast::Static(it) => {
                        let def = self.static_to_def(container.with_value(it))?;
                        DefWithBodyId::from(def).into()
                    },
-                    ast::ConstDef(it) => {
+                    ast::Const(it) => {
                        let def = self.const_to_def(container.with_value(it))?;
                        DefWithBodyId::from(def).into()
                    },
-                    ast::TypeAliasDef(it) => {
+                    ast::TypeAlias(it) => {
                        let def = self.type_alias_to_def(container.with_value(it))?;
                        def.into()
                    },
@@ -213,12 +204,12 @@ impl SourceToDefCtx<'_, '_> {
        for container in src.cloned().ancestors_with_macros(self.db.upcast()).skip(1) {
            let res: GenericDefId = match_ast! {
                match (container.value) {
-                    ast::FnDef(it) => self.fn_to_def(container.with_value(it))?.into(),
+                    ast::Fn(it) => self.fn_to_def(container.with_value(it))?.into(),
-                    ast::StructDef(it) => self.struct_to_def(container.with_value(it))?.into(),
+                    ast::Struct(it) => self.struct_to_def(container.with_value(it))?.into(),
-                    ast::EnumDef(it) => self.enum_to_def(container.with_value(it))?.into(),
+                    ast::Enum(it) => self.enum_to_def(container.with_value(it))?.into(),
-                    ast::TraitDef(it) => self.trait_to_def(container.with_value(it))?.into(),
+                    ast::Trait(it) => self.trait_to_def(container.with_value(it))?.into(),
-                    ast::TypeAliasDef(it) => self.type_alias_to_def(container.with_value(it))?.into(),
+                    ast::TypeAlias(it) => self.type_alias_to_def(container.with_value(it))?.into(),
-                    ast::ImplDef(it) => self.impl_to_def(container.with_value(it))?.into(),
+                    ast::Impl(it) => self.impl_to_def(container.with_value(it))?.into(),
                    _ => continue,
                }
            };
@@ -231,9 +222,9 @@ impl SourceToDefCtx<'_, '_> {
        for container in src.cloned().ancestors_with_macros(self.db.upcast()).skip(1) {
            let res: DefWithBodyId = match_ast! {
                match (container.value) {
-                    ast::ConstDef(it) => self.const_to_def(container.with_value(it))?.into(),
+                    ast::Const(it) => self.const_to_def(container.with_value(it))?.into(),
-                    ast::StaticDef(it) => self.static_to_def(container.with_value(it))?.into(),
+                    ast::Static(it) => self.static_to_def(container.with_value(it))?.into(),
-                    ast::FnDef(it) => self.fn_to_def(container.with_value(it))?.into(),
+                    ast::Fn(it) => self.fn_to_def(container.with_value(it))?.into(),
                    _ => continue,
                }
            };
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index 86a47a9e5..d0cb62ef0 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -159,7 +159,7 @@ impl SourceAnalyzer {
    pub(crate) fn resolve_record_field(
        &self,
        db: &dyn HirDatabase,
-        field: &ast::RecordField,
+        field: &ast::RecordExprField,
    ) -> Option<(Field, Option<Local>)> {
        let expr = field.expr()?;
        let expr_id = self.expr_id(db, &expr)?;
@@ -182,7 +182,7 @@ impl SourceAnalyzer {
    pub(crate) fn resolve_record_field_pat(
        &self,
        _db: &dyn HirDatabase,
-        field: &ast::RecordFieldPat,
+        field: &ast::RecordPatField,
    ) -> Option<Field> {
        let pat_id = self.pat_id(&field.pat()?)?;
        let struct_field = self.infer.as_ref()?.record_field_pat_resolution(pat_id)?;
@@ -202,7 +202,7 @@ impl SourceAnalyzer {
    pub(crate) fn resolve_bind_pat_to_const(
        &self,
        db: &dyn HirDatabase,
-        pat: &ast::BindPat,
+        pat: &ast::IdentPat,
    ) -> Option<ModuleDef> {
        let pat_id = self.pat_id(&pat.clone().into())?;
        let body = self.body.as_ref()?;
@@ -246,7 +246,7 @@ impl SourceAnalyzer {
            }
        }
-        if let Some(rec_lit) = path.syntax().parent().and_then(ast::RecordLit::cast) {
+        if let Some(rec_lit) = path.syntax().parent().and_then(ast::RecordExpr::cast) {
            let expr_id = self.expr_id(db, &rec_lit.into())?;
            if let Some(VariantId::EnumVariantId(variant)) =
                self.infer.as_ref()?.variant_resolution_for_expr(expr_id)
@@ -284,7 +284,7 @@ impl SourceAnalyzer {
    pub(crate) fn record_literal_missing_fields(
        &self,
        db: &dyn HirDatabase,
-        literal: &ast::RecordLit,
+        literal: &ast::RecordExpr,
    ) -> Option<Vec<(Field, Type)>> {
        let krate = self.resolver.krate()?;
        let body = self.body.as_ref()?;
@@ -358,7 +358,7 @@ impl SourceAnalyzer {
    pub(crate) fn resolve_variant(
        &self,
        db: &dyn HirDatabase,
-        record_lit: ast::RecordLit,
+        record_lit: ast::RecordExpr,
    ) -> Option<VariantId> {
        let infer = self.infer.as_ref()?;
        let expr_id = self.expr_id(db, &record_lit.into())?;
@@ -405,8 +405,7 @@ fn scope_for_offset(
            )
        })
        .map(|(expr_range, scope)| {
-            adjust(db, scopes, source_map, expr_range, offset.file_id, offset.value)
+            adjust(db, scopes, source_map, expr_range, offset).unwrap_or(*scope)
-                .unwrap_or(*scope)
        })
 }
@@ -417,8 +416,7 @@ fn adjust(
    scopes: &ExprScopes,
    source_map: &BodySourceMap,
    expr_range: TextRange,
-    file_id: HirFileId,
+    offset: InFile<TextSize>,
-    offset: TextSize,
 ) -> Option<ScopeId> {
    let child_scopes = scopes
        .scope_by_expr()
@@ -426,7 +424,7 @@ fn adjust(
        .filter_map(|(id, scope)| {
            let source = source_map.expr_syntax(*id).ok()?;
            // FIXME: correctly handle macro expansion
-            if source.file_id != file_id {
+            if source.file_id != offset.file_id {
                return None;
            }
            let root = source.file_syntax(db.upcast());
@@ -434,7 +432,7 @@ fn adjust(
            Some((node.syntax().text_range(), scope))
        })
        .filter(|&(range, _)| {
-            range.start() <= offset && expr_range.contains_range(range) && range != expr_range
+            range.start() <= offset.value && expr_range.contains_range(range) && range != expr_range
        });
    child_scopes
diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index 4994a2125..6cb56a1cd 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -8,7 +8,7 @@ use hir_expand::{
    InFile,
 };
 use ra_arena::{map::ArenaMap, Arena};
-use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner, VisibilityOwner};
+use ra_syntax::ast::{self, NameOwner, VisibilityOwner};
 use crate::{
    body::{CfgExpander, LowerCtx},
@@ -112,7 +112,7 @@ impl EnumData {
 impl HasChildSource for EnumId {
    type ChildId = LocalEnumVariantId;
-    type Value = ast::EnumVariant;
+    type Value = ast::Variant;
    fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<Self::ChildId, Self::Value>> {
        let src = self.lookup(db).source(db);
        let mut trace = Trace::new_for_map();
@@ -123,8 +123,8 @@ impl HasChildSource for EnumId {
 fn lower_enum(
    db: &dyn DefDatabase,
-    trace: &mut Trace<EnumVariantData, ast::EnumVariant>,
+    trace: &mut Trace<EnumVariantData, ast::Variant>,
-    ast: &InFile<ast::EnumDef>,
+    ast: &InFile<ast::Enum>,
    module_id: ModuleId,
 ) {
    let expander = CfgExpander::new(db, ast.file_id, module_id.krate);
@@ -179,7 +179,7 @@ impl VariantData {
 impl HasChildSource for VariantId {
    type ChildId = LocalFieldId;
-    type Value = Either<ast::TupleFieldDef, ast::RecordFieldDef>;
+    type Value = Either<ast::TupleField, ast::RecordField>;
    fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<Self::ChildId, Self::Value>> {
        let (src, module_id) = match self {
@@ -194,7 +194,7 @@ impl HasChildSource for VariantId {
            }
            VariantId::UnionId(it) => (
                it.lookup(db).source(db).map(|it| {
-                    it.record_field_def_list()
+                    it.record_field_list()
                        .map(ast::StructKind::Record)
                        .unwrap_or(ast::StructKind::Unit)
                }),
@@ -218,7 +218,7 @@ pub enum StructKind {
 fn lower_struct(
    db: &dyn DefDatabase,
    expander: &mut CfgExpander,
-    trace: &mut Trace<FieldData, Either<ast::TupleFieldDef, ast::RecordFieldDef>>,
+    trace: &mut Trace<FieldData, Either<ast::TupleField, ast::RecordField>>,
    ast: &InFile<ast::StructKind>,
 ) -> StructKind {
    let ctx = LowerCtx::new(db, ast.file_id);
@@ -234,7 +234,7 @@ fn lower_struct(
                    || Either::Left(fd.clone()),
                    || FieldData {
                        name: Name::new_tuple_field(i),
-                        type_ref: TypeRef::from_ast_opt(&ctx, fd.type_ref()),
+                        type_ref: TypeRef::from_ast_opt(&ctx, fd.ty()),
                        visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())),
                    },
                );
@@ -251,7 +251,7 @@ fn lower_struct(
                    || Either::Right(fd.clone()),
                    || FieldData {
                        name: fd.name().map(|n| n.as_name()).unwrap_or_else(Name::missing),
-                        type_ref: TypeRef::from_ast_opt(&ctx, fd.ascribed_type()),
+                        type_ref: TypeRef::from_ast_opt(&ctx, fd.ty()),
                        visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())),
                    },
                );
diff --git a/crates/ra_hir_def/src/attr.rs b/crates/ra_hir_def/src/attr.rs
index 70ccd4305..050832ce0 100644
--- a/crates/ra_hir_def/src/attr.rs
+++ b/crates/ra_hir_def/src/attr.rs
@@ -151,18 +151,15 @@ pub enum AttrInput {
 impl Attr {
    fn from_src(ast: ast::Attr, hygiene: &Hygiene) -> Option<Attr> {
        let path = ModPath::from_src(ast.path()?, hygiene)?;
-        let input = match ast.input() {
+        let input = if let Some(lit) = ast.literal() {
-            None => None,
+            // FIXME: escape? raw string?
-            Some(ast::AttrInput::Literal(lit)) => {
+            let value = lit.syntax().first_token()?.text().trim_matches('"').into();
-                // FIXME: escape? raw string?
+            Some(AttrInput::Literal(value))
-                let value = lit.syntax().first_token()?.text().trim_matches('"').into();
+        } else if let Some(tt) = ast.token_tree() {
-                Some(AttrInput::Literal(value))
+            Some(AttrInput::TokenTree(ast_to_token_tree(&tt)?.0))
-            }
+        } else {
-            Some(ast::AttrInput::TokenTree(tt)) => {
+            None
-                Some(AttrInput::TokenTree(ast_to_token_tree(&tt)?.0))
-            }
        };
        Some(Attr { path, input })
    }
 }
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index 2fe04db2b..d5f18b920 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -216,7 +216,7 @@ pub struct BodySourceMap {
    expr_map_back: ArenaMap<ExprId, Result<ExprSource, SyntheticSyntax>>,
    pat_map: FxHashMap<PatSource, PatId>,
    pat_map_back: ArenaMap<PatId, Result<PatSource, SyntheticSyntax>>,
-    field_map: FxHashMap<(ExprId, usize), InFile<AstPtr<ast::RecordField>>>,
+    field_map: FxHashMap<(ExprId, usize), InFile<AstPtr<ast::RecordExprField>>>,
    expansions: FxHashMap<InFile<AstPtr<ast::MacroCall>>, HirFileId>,
 }
@@ -314,7 +314,7 @@ impl BodySourceMap {
        self.pat_map.get(&src).cloned()
    }
-    pub fn field_syntax(&self, expr: ExprId, field: usize) -> InFile<AstPtr<ast::RecordField>> {
+    pub fn field_syntax(&self, expr: ExprId, field: usize) -> InFile<AstPtr<ast::RecordExprField>> {
        self.field_map[&(expr, field)].clone()
    }
 }
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index c6bc85e2f..f5c37edb3 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -1,6 +1,8 @@
 //! Transforms `ast::Expr` into an equivalent `hir_def::expr::Expr`
 //! representation.
+use std::{any::type_name, sync::Arc};
 use either::Either;
 use hir_expand::{
    hygiene::Hygiene,
@@ -10,11 +12,12 @@ use hir_expand::{
 use ra_arena::Arena;
 use ra_syntax::{
    ast::{
-        self, ArgListOwner, ArrayExprKind, LiteralKind, LoopBodyOwner, ModuleItemOwner, NameOwner,
+        self, ArgListOwner, ArrayExprKind, AstChildren, LiteralKind, LoopBodyOwner, NameOwner,
-        SlicePatComponents, TypeAscriptionOwner,
+        SlicePatComponents,
    },
    AstNode, AstPtr,
 };
+use rustc_hash::FxHashMap;
 use test_utils::mark;
 use crate::{
@@ -35,9 +38,6 @@ use crate::{
 };
 use super::{ExprSource, PatSource};
-use ast::AstChildren;
-use rustc_hash::FxHashMap;
-use std::{any::type_name, sync::Arc};
 pub(crate) struct LowerCtx {
    hygiene: Hygiene,
@@ -224,9 +224,22 @@ impl ExprCollector<'_> {
                    self.alloc_expr(Expr::Unsafe { body }, syntax_ptr)
                }
                // FIXME: we need to record these effects somewhere...
-                ast::Effect::Async(_) | ast::Effect::Label(_) => {
+                ast::Effect::Label(label) => match e.block_expr() {
-                    self.collect_block_opt(e.block_expr())
+                    Some(block) => {
-                }
+                        let res = self.collect_block(block);
+                        match &mut self.body.exprs[res] {
+                            Expr::Block { label: block_label, .. } => {
+                                *block_label =