259 files changed, 12034 insertions, 11202 deletions

diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index 52b4c82db..9ac65ab39 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -85,6 +85,7 @@ impl<'a> SubstituteTypeParams<'a> {
             ast::TypeRef::PathType(path_type) => path_type.path()?,
             _ => return None,
         };
+        // FIXME: use `hir::Path::from_src` instead.
         let path = hir::Path::from_ast(path)?;
         let resolution = self.source_scope.resolve_hir_path(&path)?;
         match resolution {
@@ -128,6 +129,7 @@ impl<'a> QualifyPaths<'a> {
             // don't try to qualify `Fn(Foo) -> Bar` paths, they are in prelude anyway
             return None;
         }
+        // FIXME: use `hir::Path::from_src` instead.
         let hir_path = hir::Path::from_ast(p.clone());
         let resolution = self.source_scope.resolve_hir_path(&hir_path?)?;
         match resolution {
diff --git a/crates/ra_assists/src/doc_tests/generated.rs b/crates/ra_assists/src/doc_tests/generated.rs
index e4fa9ee36..6696cc832 100644
--- a/crates/ra_assists/src/doc_tests/generated.rs
+++ b/crates/ra_assists/src/doc_tests/generated.rs
@@ -180,7 +180,9 @@ trait Trait<T> {
 }
 
 impl Trait<u32> for () {
-    fn foo(&self) -> u32 { todo!() }
+    fn foo(&self) -> u32 {
+        todo!()
+    }
 
 }
 "#####,
@@ -726,3 +728,22 @@ use std::{collections::HashMap};
 "#####,
     )
 }
+
+#[test]
+fn doctest_unwrap_block() {
+    check(
+        "unwrap_block",
+        r#####"
+fn foo() {
+    if true {<|>
+        println!("foo");
+    }
+}
+"#####,
+        r#####"
+fn foo() {
+    println!("foo");
+}
+"#####,
+    )
+}
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 2d6d44980..e466c9a86 100644
--- a/crates/ra_assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
@@ -1,6 +1,10 @@
 use hir::HasSource;
 use ra_syntax::{
-    ast::{self, edit, make, AstNode, NameOwner},
+    ast::{
+        self,
+        edit::{self, IndentLevel},
+        make, AstNode, NameOwner,
+    },
     SmolStr,
 };
 
@@ -40,7 +44,9 @@ enum AddMissingImplMembersMode {
 // }
 //
 // impl Trait<u32> for () {
-//     fn foo(&self) -> u32 { todo!() }
+//     fn foo(&self) -> u32 {
+//         todo!()
+//     }
 //
 // }
 // ```
@@ -165,7 +171,9 @@ fn add_missing_impl_members_inner(
 
 fn add_body(fn_def: ast::FnDef) -> ast::FnDef {
     if fn_def.body().is_none() {
-        fn_def.with_body(make::block_from_expr(make::expr_todo()))
+        let body = make::block_expr(None, Some(make::expr_todo()));
+        let body = IndentLevel(1).increase_indent(body);
+        fn_def.with_body(body)
     } else {
         fn_def
     }
@@ -181,7 +189,7 @@ mod tests {
     fn test_add_missing_impl_members() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 trait Foo {
     type Output;
 
@@ -197,8 +205,8 @@ struct S;
 impl Foo for S {
     fn bar(&self) {}
 <|>
-}",
-            "
+}"#,
+            r#"
 trait Foo {
     type Output;
 
@@ -215,10 +223,14 @@ impl Foo for S {
     fn bar(&self) {}
     <|>type Output;
     const CONST: usize = 42;
-    fn foo(&self) { todo!() }
-    fn baz(&self) { todo!() }
+    fn foo(&self) {
+        todo!()
+    }
+    fn baz(&self) {
+        todo!()
+    }
 
-}",
+}"#,
         );
     }
 
@@ -226,7 +238,7 @@ impl Foo for S {
     fn test_copied_overriden_members() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 trait Foo {
     fn foo(&self);
     fn bar(&self) -> bool { true }
@@ -238,8 +250,8 @@ struct S;
 impl Foo for S {
     fn bar(&self) {}
 <|>
-}",
-            "
+}"#,
+            r#"
 trait Foo {
     fn foo(&self);
     fn bar(&self) -> bool { true }
@@ -250,9 +262,11 @@ struct S;
 
 impl Foo for S {
     fn bar(&self) {}
-    <|>fn foo(&self) { todo!() }
+    <|>fn foo(&self) {
+        todo!()
+    }
 
-}",
+}"#,
         );
     }
 
@@ -260,16 +274,18 @@ impl Foo for S {
     fn test_empty_impl_def() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 trait Foo { fn foo(&self); }
 struct S;
-impl Foo for S { <|> }",
-            "
+impl Foo for S { <|> }"#,
+            r#"
 trait Foo { fn foo(&self); }
 struct S;
 impl Foo for S {
-    <|>fn foo(&self) { todo!() }
-}",
+    <|>fn foo(&self) {
+        todo!()
+    }
+}"#,
         );
     }
 
@@ -277,16 +293,18 @@ impl Foo for S {
     fn fill_in_type_params_1() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 trait Foo<T> { fn foo(&self, t: T) -> &T; }
 struct S;
-impl Foo<u32> for S { <|> }",
-            "
+impl Foo<u32> for S { <|> }"#,
+            r#"
 trait Foo<T> { fn foo(&self, t: T) -> &T; }
 struct S;
 impl Foo<u32> for S {
-    <|>fn foo(&self, t: u32) -> &u32 { todo!() }
-}",
+    <|>fn foo(&self, t: u32) -> &u32 {
+        todo!()
+    }
+}"#,
         );
     }
 
@@ -294,16 +312,18 @@ impl Foo<u32> for S {
     fn fill_in_type_params_2() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 trait Foo<T> { fn foo(&self, t: T) -> &T; }
 struct S;
-impl<U> Foo<U> for S { <|> }",
-            "
+impl<U> Foo<U> for S { <|> }"#,
+            r#"
 trait Foo<T> { fn foo(&self, t: T) -> &T; }
 struct S;
 impl<U> Foo<U> for S {
-    <|>fn foo(&self, t: U) -> &U { todo!() }
-}",
+    <|>fn foo(&self, t: U) -> &U {
+        todo!()
+    }
+}"#,
         );
     }
 
@@ -311,16 +331,18 @@ impl<U> Foo<U> for S {
     fn test_cursor_after_empty_impl_def() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 trait Foo { fn foo(&self); }
 struct S;
-impl Foo for S {}<|>",
-            "
+impl Foo for S {}<|>"#,
+            r#"
 trait Foo { fn foo(&self); }
 struct S;
 impl Foo for S {
-    <|>fn foo(&self) { todo!() }
-}",
+    <|>fn foo(&self) {
+        todo!()
+    }
+}"#,
         )
     }
 
@@ -328,22 +350,24 @@ impl Foo for S {
     fn test_qualify_path_1() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 mod foo {
     pub struct Bar;
     trait Foo { fn foo(&self, bar: Bar); }
 }
 struct S;
-impl foo::Foo for S { <|> }",
-            "
+impl foo::Foo for S { <|> }"#,
+            r#"
 mod foo {
     pub struct Bar;
     trait Foo { fn foo(&self, bar: Bar); }
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: foo::Bar) { todo!() }
-}",
+    <|>fn foo(&self, bar: foo::Bar) {
+        todo!()
+    }
+}"#,
         );
     }
 
@@ -351,22 +375,24 @@ impl foo::Foo for S {
     fn test_qualify_path_generic() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 mod foo {
     pub struct Bar<T>;
     trait Foo { fn foo(&self, bar: Bar<u32>); }
 }
 struct S;
-impl foo::Foo for S { <|> }",
-            "
+impl foo::Foo for S { <|> }"#,
+            r#"
 mod foo {
     pub struct Bar<T>;
     trait Foo { fn foo(&self, bar: Bar<u32>); }
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: foo::Bar<u32>) { todo!() }
-}",
+    <|>fn foo(&self, bar: foo::Bar<u32>) {
+        todo!()
+    }
+}"#,
         );
     }
 
@@ -374,22 +400,24 @@ impl foo::Foo for S {
     fn test_qualify_path_and_substitute_param() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 mod foo {
     pub struct Bar<T>;
     trait Foo<T> { fn foo(&self, bar: Bar<T>); }
 }
 struct S;
-impl foo::Foo<u32> for S { <|> }",
-            "
+impl foo::Foo<u32> for S { <|> }"#,
+            r#"
 mod foo {
     pub struct Bar<T>;
     trait Foo<T> { fn foo(&self, bar: Bar<T>); }
 }
 struct S;
 impl foo::Foo<u32> for S {
-    <|>fn foo(&self, bar: foo::Bar<u32>) { todo!() }
-}",
+    <|>fn foo(&self, bar: foo::Bar<u32>) {
+        todo!()
+    }
+}"#,
         );
     }
 
@@ -398,15 +426,15 @@ impl foo::Foo<u32> for S {
         // when substituting params, the substituted param should not be qualified!
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 mod foo {
     trait Foo<T> { fn foo(&self, bar: T); }
     pub struct Param;
 }
 struct Param;
 struct S;
-impl foo::Foo<Param> for S { <|> }",
-            "
+impl foo::Foo<Param> for S { <|> }"#,
+            r#"
 mod foo {
     trait Foo<T> { fn foo(&self, bar: T); }
     pub struct Param;
@@ -414,8 +442,10 @@ mod foo {
 struct Param;
 struct S;
 impl foo::Foo<Param> for S {
-    <|>fn foo(&self, bar: Param) { todo!() }
-}",
+    <|>fn foo(&self, bar: Param) {
+        todo!()
+    }
+}"#,
         );
     }
 
@@ -423,15 +453,15 @@ impl foo::Foo<Param> for S {
     fn test_qualify_path_associated_item() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 mod foo {
     pub struct Bar<T>;
     impl Bar<T> { type Assoc = u32; }
     trait Foo { fn foo(&self, bar: Bar<u32>::Assoc); }
 }
 struct S;
-impl foo::Foo for S { <|> }",
-            "
+impl foo::Foo for S { <|> }"#,
+            r#"
 mod foo {
     pub struct Bar<T>;
     impl Bar<T> { type Assoc = u32; }
@@ -439,8 +469,10 @@ mod foo {
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: foo::Bar<u32>::Assoc) { todo!() }
-}",
+    <|>fn foo(&self, bar: foo::Bar<u32>::Assoc) {
+        todo!()
+    }
+}"#,
         );
     }
 
@@ -448,15 +480,15 @@ impl foo::Foo for S {
     fn test_qualify_path_nested() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 mod foo {
     pub struct Bar<T>;
     pub struct Baz;
     trait Foo { fn foo(&self, bar: Bar<Baz>); }
 }
 struct S;
-impl foo::Foo for S { <|> }",
-            "
+impl foo::Foo for S { <|> }"#,
+            r#"
 mod foo {
     pub struct Bar<T>;
     pub struct Baz;
@@ -464,8 +496,10 @@ mod foo {
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: foo::Bar<foo::Baz>) { todo!() }
-}",
+    <|>fn foo(&self, bar: foo::Bar<foo::Baz>) {
+        todo!()
+    }
+}"#,
         );
     }
 
@@ -473,22 +507,24 @@ impl foo::Foo for S {
     fn test_qualify_path_fn_trait_notation() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 mod foo {
     pub trait Fn<Args> { type Output; }
     trait Foo { fn foo(&self, bar: dyn Fn(u32) -> i32); }
 }
 struct S;
-impl foo::Foo for S { <|> }",
-            "
+impl foo::Foo for S { <|> }"#,
+            r#"
 mod foo {
     pub trait Fn<Args> { type Output; }
     trait Foo { fn foo(&self, bar: dyn Fn(u32) -> i32); }
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: dyn Fn(u32) -> i32) { todo!() }
-}",
+    <|>fn foo(&self, bar: dyn Fn(u32) -> i32) {
+        todo!()
+    }
+}"#,
         );
     }
 
@@ -496,10 +532,10 @@ impl foo::Foo for S {
     fn test_empty_trait() {
         check_assist_not_applicable(
             add_missing_impl_members,
-            "
+            r#"
 trait Foo;
 struct S;
-impl Foo for S { <|> }",
+impl Foo for S { <|> }"#,
         )
     }
 
@@ -507,13 +543,13 @@ impl Foo for S { <|> }",
     fn test_ignore_unnamed_trait_members_and_default_methods() {
         check_assist_not_applicable(
             add_missing_impl_members,
-            "
+            r#"
 trait Foo {
     fn (arg: u32);
     fn valid(some: u32) -> bool { false }
 }
 struct S;
-impl Foo for S { <|> }",
+impl Foo for S { <|> }"#,
         )
     }
 
@@ -544,7 +580,9 @@ trait Foo {
 struct S;
 impl Foo for S {
     <|>type Output;
-    fn foo(&self) { todo!() }
+    fn foo(&self) {
+        todo!()
+    }
 }"#,
         )
     }
@@ -553,7 +591,7 @@ impl Foo for S {
     fn test_default_methods() {
         check_assist(
             add_missing_default_members,
-            "
+            r#"
 trait Foo {
     type Output;
 
@@ -563,8 +601,8 @@ trait Foo {
     fn foo(some: u32) -> bool;
 }
 struct S;
-impl Foo for S { <|> }",
-            "
+impl Foo for S { <|> }"#,
+            r#"
 trait Foo {
     type Output;
 
@@ -576,7 +614,7 @@ trait Foo {
 struct S;
 impl Foo for S {
     <|>fn valid(some: u32) -> bool { false }
-}",
+}"#,
         )
     }
 }
diff --git a/crates/ra_assists/src/handlers/early_return.rs b/crates/ra_assists/src/handlers/early_return.rs
index ea6c56f8c..eede2fe91 100644
--- a/crates/ra_assists/src/handlers/early_return.rs
+++ b/crates/ra_assists/src/handlers/early_return.rs
@@ -2,7 +2,7 @@ use std::{iter::once, ops::RangeInclusive};
 
 use ra_syntax::{
     algo::replace_children,
-    ast::{self, edit::IndentLevel, make, Block, Pat::TupleStructPat},
+    ast::{self, edit::IndentLevel, make},
     AstNode,
     SyntaxKind::{FN_DEF, LOOP_EXPR, L_CURLY, R_CURLY, WHILE_EXPR, WHITESPACE},
     SyntaxNode,
@@ -47,7 +47,7 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
     // Check if there is an IfLet that we can handle.
     let if_let_pat = match cond.pat() {
         None => None, // No IfLet, supported.
-        Some(TupleStructPat(pat)) if pat.args().count() == 1 => {
+        Some(ast::Pat::TupleStructPat(pat)) if pat.args().count() == 1 => {
             let path = pat.path()?;
             match path.qualifier() {
                 None => {
@@ -61,9 +61,9 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
     };
 
     let cond_expr = cond.expr()?;
-    let then_block = if_expr.then_branch()?.block()?;
+    let then_block = if_expr.then_branch()?;
 
-    let parent_block = if_expr.syntax().parent()?.ancestors().find_map(ast::Block::cast)?;
+    let parent_block = if_expr.syntax().parent()?.ancestors().find_map(ast::BlockExpr::cast)?;
 
     if parent_block.expr()? != if_expr.clone().into() {
         return None;
@@ -80,7 +80,7 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
         return None;
     }
 
-    let parent_container = parent_block.syntax().parent()?.parent()?;
+    let parent_container = parent_block.syntax().parent()?;
 
     let early_expression: ast::Expr = match parent_container.kind() {
         WHILE_EXPR | LOOP_EXPR => make::expr_continue(),
@@ -144,13 +144,13 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
             }
         };
         edit.target(if_expr.syntax().text_range());
-        edit.replace_ast(parent_block, ast::Block::cast(new_block).unwrap());
+        edit.replace_ast(parent_block, ast::BlockExpr::cast(new_block).unwrap());
         edit.set_cursor(cursor_position);
 
         fn replace(
             new_expr: &SyntaxNode,
-            then_block: &Block,
-            parent_block: &Block,
+            then_block: &ast::BlockExpr,
+            parent_block: &ast::BlockExpr,
             if_expr: &ast::IfExpr,
         ) -> SyntaxNode {
             let then_block_items = IndentLevel::from(1).decrease_indent(then_block.clone());
diff --git a/crates/ra_assists/src/handlers/inline_local_variable.rs b/crates/ra_assists/src/handlers/inline_local_variable.rs
index f5702f6e0..60ec536a7 100644
--- a/crates/ra_assists/src/handlers/inline_local_variable.rs
+++ b/crates/ra_assists/src/handlers/inline_local_variable.rs
@@ -89,6 +89,7 @@ pub(crate) fn inline_local_variable(ctx: AssistCtx) -> Option<Assist> {
             | (ast::Expr::ParenExpr(_), _)
             | (ast::Expr::PathExpr(_), _)
             | (ast::Expr::BlockExpr(_), _)
+            | (ast::Expr::EffectExpr(_), _)
             | (_, ast::Expr::CallExpr(_))
             | (_, ast::Expr::TupleExpr(_))
             | (_, ast::Expr::ArrayExpr(_))
diff --git a/crates/ra_assists/src/handlers/introduce_variable.rs b/crates/ra_assists/src/handlers/introduce_variable.rs
index eda9ac296..39c656305 100644
--- a/crates/ra_assists/src/handlers/introduce_variable.rs
+++ b/crates/ra_assists/src/handlers/introduce_variable.rs
@@ -111,7 +111,7 @@ fn valid_target_expr(node: SyntaxNode) -> Option<ast::Expr> {
 /// expression like a lambda or match arm.
 fn anchor_stmt(expr: ast::Expr) -> Option<(SyntaxNode, bool)> {
     expr.syntax().ancestors().find_map(|node| {
-        if let Some(expr) = node.parent().and_then(ast::Block::cast).and_then(|it| it.expr()) {
+        if let Some(expr) = node.parent().and_then(ast::BlockExpr::cast).and_then(|it| it.expr()) {
             if expr.syntax() == &node {
                 tested_by!(test_introduce_var_last_expr);
                 return Some((node, false));
diff --git a/crates/ra_assists/src/handlers/move_guard.rs b/crates/ra_assists/src/handlers/move_guard.rs
index d5ccdd91c..b084dd9ee 100644
--- a/crates/ra_assists/src/handlers/move_guard.rs
+++ b/crates/ra_assists/src/handlers/move_guard.rs
@@ -113,9 +113,9 @@ pub(crate) fn move_arm_cond_to_match_guard(ctx: AssistCtx) -> Option<Assist> {
         "Move condition to match guard",
         |edit| {
             edit.target(if_expr.syntax().text_range());
-            let then_only_expr = then_block.block().and_then(|it| it.statements().next()).is_none();
+            let then_only_expr = then_block.statements().next().is_none();
 
-            match &then_block.block().and_then(|it| it.expr()) {
+            match &then_block.expr() {
                 Some(then_expr) if then_only_expr => {
                     edit.replace(if_expr.syntax().text_range(), then_expr.syntax().text())
                 }
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 2f02df303..918e8dd8d 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
@@ -27,7 +27,7 @@ pub(crate) fn replace_qualified_name_with_use(ctx: AssistCtx) -> Option<Assist>
         return None;
     }
 
-    let hir_path = hir::Path::from_ast(path.clone())?;
+    let hir_path = ctx.sema.lower_path(&path)?;
     let segments = collect_hir_path_segments(&hir_path)?;
     if segments.len() < 2 {
         return None;
diff --git a/crates/ra_assists/src/handlers/unwrap_block.rs b/crates/ra_assists/src/handlers/unwrap_block.rs
new file mode 100644
index 000000000..58649c47e
--- /dev/null
+++ b/crates/ra_assists/src/handlers/unwrap_block.rs
@@ -0,0 +1,348 @@
+use crate::{Assist, AssistCtx, AssistId};
+
+use ast::{BlockExpr, Expr, ForExpr, IfExpr, LoopBodyOwner, LoopExpr, WhileExpr};
+use ra_fmt::unwrap_trivial_block;
+use ra_syntax::{ast, AstNode, TextRange, T};
+
+// Assist: unwrap_block
+//
+// This assist removes if...else, for, while and loop control statements to just keep the body.
+//
+// ```
+// fn foo() {
+//     if true {<|>
+//         println!("foo");
+//     }
+// }
+// ```
+// ->
+// ```
+// fn foo() {
+//     println!("foo");
+// }
+// ```
+pub(crate) fn unwrap_block(ctx: AssistCtx) -> Option<Assist> {
+    let l_curly_token = ctx.find_token_at_offset(T!['{'])?;
+
+    let res = if let Some(if_expr) = l_curly_token.ancestors().find_map(IfExpr::cast) {
+        // if expression
+        let expr_to_unwrap = if_expr.blocks().find_map(|expr| extract_expr(ctx.frange.range, expr));
+        let expr_to_unwrap = expr_to_unwrap?;
+        // Find if we are in a else if block
+        let ancestor = if_expr.syntax().ancestors().skip(1).find_map(ast::IfExpr::cast);
+
+        if let Some(ancestor) = ancestor {
+            Some((ast::Expr::IfExpr(ancestor), expr_to_unwrap))
+        } else {
+            Some((ast::Expr::IfExpr(if_expr), expr_to_unwrap))
+        }
+    } else if let Some(for_expr) = l_curly_token.ancestors().find_map(ForExpr::cast) {
+        // for expression
+        let block_expr = for_expr.loop_body()?;
+        extract_expr(ctx.frange.range, block_expr)
+            .map(|expr_to_unwrap| (ast::Expr::ForExpr(for_expr), expr_to_unwrap))
+    } else if let Some(while_expr) = l_curly_token.ancestors().find_map(WhileExpr::cast) {
+        // while expression
+        let block_expr = while_expr.loop_body()?;
+        extract_expr(ctx.frange.range, block_expr)
+            .map(|expr_to_unwrap| (ast::Expr::WhileExpr(while_expr), expr_to_unwrap))
+    } else if let Some(loop_expr) = l_curly_token.ancestors().find_map(LoopExpr::cast) {
+        // loop expression
+        let block_expr = loop_expr.loop_body()?;
+        extract_expr(ctx.frange.range, block_expr)
+            .map(|expr_to_unwrap| (ast::Expr::LoopExpr(loop_expr), expr_to_unwrap))
+    } else {
+        None
+    };
+
+    let (expr, expr_to_unwrap) = res?;
+    ctx.add_assist(AssistId("unwrap_block"), "Unwrap block", |edit| {
+        edit.set_cursor(expr.syntax().text_range().start());
+        edit.target(expr_to_unwrap.syntax().text_range());
+
+        let pat_start: &[_] = &[' ', '{', '\n'];
+        let expr_to_unwrap = expr_to_unwrap.to_string();
+        let expr_string = expr_to_unwrap.trim_start_matches(pat_start);
+        let mut expr_string_lines: Vec<&str> = expr_string.lines().collect();
+        expr_string_lines.pop(); // Delete last line
+
+        let expr_string = expr_string_lines
+            .into_iter()
+            .map(|line| line.replacen("    ", "", 1)) // Delete indentation
+            .collect::<Vec<String>>()
+            .join("\n");
+
+        edit.replace(expr.syntax().text_range(), expr_string);
+    })
+}
+
+fn extract_expr(cursor_range: TextRange, block: BlockExpr) -> Option<Expr> {
+    let cursor_in_range = block.l_curly_token()?.text_range().contains_range(cursor_range);
+
+    if cursor_in_range {
+        Some(unwrap_trivial_block(block))
+    } else {
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::helpers::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+
+    #[test]
+    fn simple_if() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                bar();
+                if true {<|>
+                    foo();
+
+                    //comment
+                    bar();
+                } else {
+                    println!("bar");
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                bar();
+                <|>foo();
+
+                //comment
+                bar();
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn simple_if_else() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                bar();
+                if true {
+                    foo();
+
+                    //comment
+                    bar();
+                } else {<|>
+                    println!("bar");
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                bar();
+                <|>println!("bar");
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn simple_if_else_if() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                //bar();
+                if true {
+                    println!("true");
+
+                    //comment
+                    //bar();
+                } else if false {<|>
+                    println!("bar");
+                } else {
+                    println!("foo");
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                //bar();
+                <|>println!("bar");
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn simple_if_bad_cursor_position() {
+        check_assist_not_applicable(
+            unwrap_block,
+            r#"
+            fn main() {
+                bar();<|>
+                if true {
+                    foo();
+
+                    //comment
+                    bar();
+                } else {
+                    println!("bar");
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn simple_for() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                for i in 0..5 {<|>
+                    if true {
+                        foo();
+
+                        //comment
+                        bar();
+                    } else {
+                        println!("bar");
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                <|>if true {
+                    foo();
+
+                    //comment
+                    bar();
+                } else {
+                    println!("bar");
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn simple_if_in_for() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                for i in 0..5 {
+                    if true {<|>
+                        foo();
+
+                        //comment
+                        bar();
+                    } else {
+                        println!("bar");
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                for i in 0..5 {
+                    <|>foo();
+
+                    //comment
+                    bar();
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn simple_loop() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                loop {<|>
+                    if true {
+                        foo();
+
+                        //comment
+                        bar();
+                    } else {
+                        println!("bar");
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                <|>if true {
+                    foo();
+
+                    //comment
+                    bar();
+                } else {
+                    println!("bar");
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn simple_while() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                while true {<|>
+                    if true {
+                        foo();
+
+                        //comment
+                        bar();
+                    } else {
+                        println!("bar");
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                <|>if true {
+                    foo();
+
+                    //comment
+                    bar();
+                } else {
+                    println!("bar");
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn simple_if_in_while_bad_cursor_position() {
+        check_assist_not_applicable(
+            unwrap_block,
+            r#"
+            fn main() {
+                while true {
+                    if true {
+                        foo();<|>
+
+                        //comment
+                        bar();
+                    } else {
+                        println!("bar");
+                    }
+                }
+            }
+            "#,
+        );
+    }
+}
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 64bd87afb..c5df86600 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -143,6 +143,7 @@ mod handlers {
     mod split_import;
     mod add_from_impl_for_enum;
     mod reorder_fields;
+    mod unwrap_block;
 
     pub(crate) fn all() -> &'static [AssistHandler] {
         &[
@@ -181,6 +182,7 @@ mod handlers {
             replace_unwrap_with_match::replace_unwrap_with_match,
             split_import::split_import,
             add_from_impl_for_enum::add_from_impl_for_enum,
+            unwrap_block::unwrap_block,
             // These are manually sorted for better priorities
             add_missing_impl_members::add_missing_impl_members,
             add_missing_impl_members::add_missing_default_members,
diff --git a/crates/ra_fmt/src/lib.rs b/crates/ra_fmt/src/lib.rs
index 1a30b2b3a..f910ded9d 100644
--- a/crates/ra_fmt/src/lib.rs
+++ b/crates/ra_fmt/src/lib.rs
@@ -42,7 +42,6 @@ pub fn unwrap_trivial_block(block: ast::BlockExpr) -> ast::Expr {
 }
 
 pub fn extract_trivial_expression(block: &ast::BlockExpr) -> Option<ast::Expr> {
-    let block = block.block()?;
     let has_anything_else = |thing: &SyntaxNode| -> bool {
         let mut non_trivial_children =
             block.syntax().children_with_tokens().filter(|it| match it.kind() {
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index af59aa1b6..a004363ee 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -19,7 +19,7 @@ use hir_def::{
 use hir_expand::{
     diagnostics::DiagnosticSink,
     name::{name, AsName},
-    MacroDefId,
+    MacroDefId, MacroDefKind,
 };
 use hir_ty::{
     autoderef, display::HirFormatter, expr::ExprValidator, method_resolution, ApplicationTy,
@@ -762,13 +762,12 @@ impl MacroDef {
 
     /// Indicate it is a proc-macro
     pub fn is_proc_macro(&self) -> bool {
-        match self.id.kind {
-            hir_expand::MacroDefKind::Declarative => false,
-            hir_expand::MacroDefKind::BuiltIn(_) => false,
-            hir_expand::MacroDefKind::BuiltInDerive(_) => false,
-            hir_expand::MacroDefKind::BuiltInEager(_) => false,
-            hir_expand::MacroDefKind::CustomDerive(_) => true,
-        }
+        matches!(self.id.kind, MacroDefKind::CustomDerive(_))
+    }
+
+    /// Indicate it is a derive macro
+    pub fn is_derive_macro(&self) -> bool {
+        matches!(self.id.kind, MacroDefKind::CustomDerive(_) | MacroDefKind::BuiltInDerive(_))
     }
 }
 
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 312ef3814..c5df4ac24 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -70,6 +70,7 @@ pub use hir_def::{
     type_ref::Mutability,
 };
 pub use hir_expand::{
-    name::Name, HirFileId, InFile, MacroCallId, MacroCallLoc, MacroDefId, MacroFile, Origin,
+    hygiene::Hygiene, name::Name, HirFileId, InFile, MacroCallId, MacroCallLoc, MacroDefId,
+    MacroFile, Origin,
 };
 pub use hir_ty::{display::HirDisplay, CallableDef};
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index a0a0f234b..515e5eb17 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -8,7 +8,7 @@ use hir_def::{
     resolver::{self, HasResolver, Resolver},
     AsMacroCall, TraitId,
 };
-use hir_expand::ExpansionInfo;
+use hir_expand::{hygiene::Hygiene, ExpansionInfo};
 use hir_ty::associated_type_shorthand_candidates;
 use itertools::Itertools;
 use ra_db::{FileId, FileRange};
@@ -246,6 +246,11 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
         self.analyze(path.syntax()).resolve_path(self.db, path)
     }
 
+    pub fn lower_path(&self, path: &ast::Path) -> Option<Path> {
+        let src = self.find_file(path.syntax().clone());
+        Path::from_src(path.clone(), &Hygiene::new(self.db.upcast(), src.file_id.into()))
+    }
+
     pub fn resolve_bind_pat_to_const(&self, pat: &ast::BindPat) -> Option<ModuleDef> {
         self.analyze(pat.syntax()).resolve_bind_pat_to_const(self.db, pat)
     }
diff --git a/crates/ra_hir/src/semantics/source_to_def.rs b/crates/ra_hir/src/semantics/source_to_def.rs
index 6f3b5b2da..8af64fdc1 100644
--- a/crates/ra_hir/src/semantics/source_to_def.rs
+++ b/crates/ra_hir/src/semantics/source_to_def.rs
@@ -151,7 +151,7 @@ impl SourceToDefCtx<'_, '_> {
         let krate = self.file_to_def(file_id)?.krate;
         let file_ast_id = self.db.ast_id_map(src.file_id).ast_id(&src.value);
         let ast_id = Some(AstId::new(src.file_id, file_ast_id));
-        Some(MacroDefId { krate: Some(krate), ast_id, kind })
+        Some(MacroDefId { krate: Some(krate), ast_id, kind, local_inner: false })
     }
 
     pub(super) fn find_container(&mut self, src: InFile<&SyntaxNode>) -> Option<ChildContainer> {
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index 74d64c97d..c63d1b847 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -224,7 +224,8 @@ impl SourceAnalyzer {
             }
         }
         // This must be a normal source file rather than macro file.
-        let hir_path = crate::Path::from_ast(path.clone())?;
+        let hir_path =
+            crate::Path::from_src(path.clone(), &Hygiene::new(db.upcast(), self.file_id))?;
         resolve_hir_path(db, &self.resolver, &hir_path)
     }
 
diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index 753becc3d..8eef51828 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -12,9 +12,15 @@ use ra_prof::profile;
 use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner, VisibilityOwner};
 
 use crate::{
-    body::CfgExpander, db::DefDatabase, src::HasChildSource, src::HasSource, trace::Trace,
-    type_ref::TypeRef, visibility::RawVisibility, EnumId, HasModule, LocalEnumVariantId,
-    LocalFieldId, Lookup, ModuleId, StructId, UnionId, VariantId,
+    body::{CfgExpander, LowerCtx},
+    db::DefDatabase,
+    src::HasChildSource,
+    src::HasSource,
+    trace::Trace,
+    type_ref::TypeRef,
+    visibility::RawVisibility,
+    EnumId, HasModule, LocalEnumVariantId, LocalFieldId, Lookup, ModuleId, StructId, UnionId,
+    VariantId,
 };
 
 /// Note that we use `StructData` for unions as well!
@@ -198,6 +204,8 @@ fn lower_struct(
     trace: &mut Trace<FieldData, Either<ast::TupleFieldDef, ast::RecordFieldDef>>,
     ast: &InFile<ast::StructKind>,
 ) -> StructKind {
+    let ctx = LowerCtx::new(db, ast.file_id);
+
     match &ast.value {
         ast::StructKind::Tuple(fl) => {
             for (i, fd) in fl.fields().enumerate() {
@@ -210,7 +218,7 @@ fn lower_struct(
                     || Either::Left(fd.clone()),
                     || FieldData {
                         name: Name::new_tuple_field(i),
-                        type_ref: TypeRef::from_ast_opt(fd.type_ref()),
+                        type_ref: TypeRef::from_ast_opt(&ctx, fd.type_ref()),
                         visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())),
                     },
                 );
@@ -228,7 +236,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(fd.ascribed_type()),
+                        type_ref: TypeRef::from_ast_opt(&ctx, fd.ascribed_type()),
                         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 5a86af8ba..576cd0c65 100644
--- a/crates/ra_hir_def/src/attr.rs
+++ b/crates/ra_hir_def/src/attr.rs
@@ -140,6 +140,7 @@ impl Attr {
     }
 }
 
+#[derive(Debug, Clone, Copy)]
 pub struct AttrQuery<'a> {
     attrs: &'a Attrs,
     key: &'static str,
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index 890cefcaf..4edaad960 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -15,6 +15,8 @@ use ra_prof::profile;
 use ra_syntax::{ast, AstNode, AstPtr};
 use rustc_hash::FxHashMap;
 
+pub(crate) use lower::LowerCtx;
+
 use crate::{
     attr::Attrs,
     db::DefDatabase,
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index f467ed3fe..687216dc3 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -3,8 +3,9 @@
 
 use either::Either;
 use hir_expand::{
+    hygiene::Hygiene,
     name::{name, AsName, Name},
-    MacroDefId, MacroDefKind,
+    HirFileId, MacroDefId, MacroDefKind,
 };
 use ra_arena::Arena;
 use ra_syntax::{
@@ -26,7 +27,7 @@ use crate::{
         LogicOp, MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement,
     },
     item_scope::BuiltinShadowMode,
-    path::GenericArgs,
+    path::{GenericArgs, Path},
     type_ref::{Mutability, TypeRef},
     AdtId, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern, ModuleDefId,
     StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
@@ -35,6 +36,23 @@ use crate::{
 use super::{ExprSource, PatSource};
 use ast::AstChildren;
 
+pub(crate) struct LowerCtx {
+    hygiene: Hygiene,
+}
+
+impl LowerCtx {
+    pub fn new(db: &dyn DefDatabase, file_id: HirFileId) -> Self {
+        LowerCtx { hygiene: Hygiene::new(db.upcast(), file_id) }
+    }
+    pub fn with_hygiene(hygiene: &Hygiene) -> Self {
+        LowerCtx { hygiene: hygiene.clone() }
+    }
+
+    pub fn lower_path(&self, ast: ast::Path) -> Option<Path> {
+        Path::from_src(ast, &self.hygiene)
+    }
+}
+
 pub(super) fn lower(
     db: &dyn DefDatabase,
     def: DefWithBodyId,
@@ -42,10 +60,13 @@ pub(super) fn lower(
     params: Option<ast::ParamList>,
     body: Option<ast::Expr>,
 ) -> (Body, BodySourceMap) {
+    let ctx = LowerCtx::new(db, expander.current_file_id.clone());
+
     ExprCollector {
         db,
         def,
         expander,
+        ctx,
         source_map: BodySourceMap::default(),
         body: Body {
             exprs: Arena::default(),
@@ -62,7 +83,7 @@ struct ExprCollector<'a> {
     db: &'a dyn DefDatabase,
     def: DefWithBodyId,
     expander: Expander,
-
+    ctx: LowerCtx,
     body: Body,
     source_map: BodySourceMap,
 }
@@ -182,6 +203,16 @@ impl ExprCollector<'_> {
 
                 self.alloc_expr(Expr::If { condition, then_branch, else_branch }, syntax_ptr)
             }
+            ast::Expr::EffectExpr(e) => match e.effect() {
+                ast::Effect::Try(_) => {
+                    let body = self.collect_block_opt(e.block_expr());
+                    self.alloc_expr(Expr::TryBlock { body }, syntax_ptr)
+                }
+                // FIXME: we need to record these effects somewhere...
+                ast::Effect::Async(_) | ast::Effect::Label(_) | ast::Effect::Unsafe(_) => {
+                    self.collect_block_opt(e.block_expr())
+                }
+            },
             ast::Expr::BlockExpr(e) => self.collect_block(e),
             ast::Expr::LoopExpr(e) => {
                 let body = self.collect_block_opt(e.loop_body());
@@ -237,7 +268,8 @@ impl ExprCollector<'_> {
                     Vec::new()
                 };
                 let method_name = e.name_ref().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
-                let generic_args = e.type_arg_list().and_then(GenericArgs::from_ast);
+                let generic_args =
+                    e.type_arg_list().and_then(|it| GenericArgs::from_ast(&self.ctx, it));
                 self.alloc_expr(
                     Expr::MethodCall { receiver, method_name, args, generic_args },
                     syntax_ptr,
@@ -343,7 +375,7 @@ impl ExprCollector<'_> {
             }
             ast::Expr::CastExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
-                let type_ref = TypeRef::from_ast_opt(e.type_ref());
+                let type_ref = TypeRef::from_ast_opt(&self.ctx, e.type_ref());
                 self.alloc_expr(Expr::Cast { expr, type_ref }, syntax_ptr)
             }
             ast::Expr::RefExpr(e) => {
@@ -365,12 +397,16 @@ impl ExprCollector<'_> {
                 if let Some(pl) = e.param_list() {
                     for param in pl.params() {
                         let pat = self.collect_pat_opt(param.pat());
-                        let type_ref = param.ascribed_type().map(TypeRef::from_ast);
+                        let type_ref =
+                            param.ascribed_type().map(|it| TypeRef::from_ast(&self.ctx, it));
                         args.push(pat);
                         arg_types.push(type_ref);
                     }
                 }
-                let ret_type = e.ret_type().and_then(|r| r.type_ref()).map(TypeRef::from_ast);
+                let ret_type = e
+                    .ret_type()
+                    .and_then(|r| r.type_ref())
+                    .map(|it| TypeRef::from_ast(&self.ctx, it));
                 let body = self.collect_expr_opt(e.body());
                 self.alloc_expr(Expr::Lambda { args, arg_types, ret_type, body }, syntax_ptr)
             }
@@ -430,6 +466,7 @@ impl ExprCollector<'_> {
                         krate: Some(self.expander.module.krate),
                         ast_id: Some(self.expander.ast_id(&e)),
                         kind: MacroDefKind::Declarative,
+                        local_inner: false,
                     };
                     self.body.item_scope.define_legacy_macro(name, mac);
 
@@ -464,19 +501,15 @@ impl ExprCollector<'_> {
         }
     }
 
-    fn collect_block(&mut self, expr: ast::BlockExpr) -> ExprId {
-        let syntax_node_ptr = AstPtr::new(&expr.clone().into());
-        let block = match expr.block() {
-            Some(block) => block,
-            None => return self.alloc_expr(Expr::Missing, syntax_node_ptr),
-        };
+    fn collect_block(&mut self, block: ast::BlockExpr) -> ExprId {
+        let syntax_node_ptr = AstPtr::new(&block.clone().into());
         self.collect_block_items(&block);
         let statements = block
             .statements()
             .map(|s| match s {
                 ast::Stmt::LetStmt(stmt) => {
                     let pat = self.collect_pat_opt(stmt.pat());
-                    let type_ref = stmt.ascribed_type().map(TypeRef::from_ast);
+                    let type_ref = stmt.ascribed_type().map(|it| TypeRef::from_ast(&self.ctx, it));
                     let initializer = stmt.initializer().map(|e| self.collect_expr(e));
                     Statement::Let { pat, type_ref, initializer }
                 }
@@ -487,7 +520,7 @@ impl ExprCollector<'_> {
         self.alloc_expr(Expr::Block { statements, tail }, syntax_node_ptr)
     }
 
-    fn collect_block_items(&mut self, block: &ast::Block) {
+    fn collect_block_items(&mut self, block: &ast::BlockExpr) {
         let container = ContainerId::DefWithBodyId(self.def);
         for item in block.items() {
             let (def, name): (ModuleDefId, Option<ast::Name>) = match item {
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index ccb682f9a..7a2067e49 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -15,6 +15,7 @@ use ra_syntax::ast::{
 
 use crate::{
     attr::Attrs,
+    body::LowerCtx,
     db::DefDatabase,
     path::{path, AssociatedTypeBinding, GenericArgs, Path},
     src::HasSource,
@@ -40,13 +41,14 @@ impl FunctionData {
     pub(crate) fn fn_data_query(db: &impl DefDatabase, func: FunctionId) -> Arc<FunctionData> {
         let loc = func.lookup(db);
         let src = loc.source(db);
+        let ctx = LowerCtx::new(db, src.file_id);
         let name = src.value.name().map(|n| n.as_name()).unwrap_or_else(Name::missing);
         let mut params = Vec::new();
         let mut has_self_param = false;
         if let Some(param_list) = src.value.param_list() {
             if let Some(self_param) = param_list.self_param() {
                 let self_type = if let Some(type_ref) = self_param.ascribed_type() {
-                    TypeRef::from_ast(type_ref)
+                    TypeRef::from_ast(&ctx, type_ref)
                 } else {
                     let self_type = TypeRef::Path(name![Self].into());
                     match self_param.kind() {
@@ -63,14 +65,14 @@ impl FunctionData {
                 has_self_param = true;
             }
             for param in param_list.params() {
-                let type_ref = TypeRef::from_ast_opt(param.ascribed_type());
+                let type_ref = TypeRef::from_ast_opt(&ctx, param.ascribed_type());
                 params.push(type_ref);
             }
         }
         let attrs = Attrs::new(&src.value, &Hygiene::new(db.upcast(), src.file_id));
 
         let ret_type = if let Some(type_ref) = src.value.ret_type().and_then(|rt| rt.type_ref()) {
-            TypeRef::from_ast(type_ref)
+            TypeRef::from_ast(&ctx, type_ref)
         } else {
             TypeRef::unit()
         };
@@ -122,7 +124,8 @@ impl TypeAliasData {
         let loc = typ.lookup(db);
         let node = loc.source(db);
         let name = node.value.name().map_or_else(Name::missing, |n| n.as_name());
-        let type_ref = node.value.type_ref().map(TypeRef::from_ast);
+        let lower_ctx = LowerCtx::new(db, node.file_id);
+        let type_ref = node.value.type_ref().map(|it| TypeRef::from_ast(&lower_ctx, it));
         let vis_default = RawVisibility::default_for_container(loc.container);
         let visibility = RawVisibility::from_ast_with_default(
             db,
@@ -130,7 +133,7 @@ impl TypeAliasData {
             node.as_ref().map(|n| n.visibility()),
         );
         let bounds = if let Some(bound_list) = node.value.type_bound_list() {
-            bound_list.bounds().map(TypeBound::from_ast).collect()
+            bound_list.bounds().map(|it| TypeBound::from_ast(&lower_ctx, it)).collect()
         } else {
             Vec::new()
         };
@@ -223,9 +226,10 @@ impl ImplData {
         let _p = profile("impl_data_query");
         let impl_loc = id.lookup(db);
         let src = impl_loc.source(db);
+        let lower_ctx = LowerCtx::new(db, src.file_id);
 
-        let target_trait = src.value.target_trait().map(TypeRef::from_ast);
-        let target_type = TypeRef::from_ast_opt(src.value.target_type());
+        let target_trait = src.value.target_trait().map(|it| TypeRef::from_ast(&lower_ctx, it));
+        let target_type = TypeRef::from_ast_opt(&lower_ctx, src.value.target_type());
         let is_negative = src.value.excl_token().is_some();
         let module_id = impl_loc.container.module(db);
 
@@ -279,8 +283,9 @@ impl ConstData {
         vis_default: RawVisibility,
         node: InFile<N>,
     ) -> ConstData {
+        let ctx = LowerCtx::new(db, node.file_id);
         let name = node.value.name().map(|n| n.as_name());
-        let type_ref = TypeRef::from_ast_opt(node.value.ascribed_type());
+        let type_ref = TypeRef::from_ast_opt(&ctx, node.value.ascribed_type());
         let visibility =
             RawVisibility::from_ast_with_default(db, vis_default, node.map(|n| n.visibility()));
         ConstData { name, type_ref, visibility }
diff --git a/crates/ra_hir_def/src/expr.rs b/crates/ra_hir_def/src/expr.rs
index aad12e123..a0cdad529 100644
--- a/crates/ra_hir_def/src/expr.rs
+++ b/crates/ra_hir_def/src/expr.rs
@@ -101,6 +101,9 @@ pub enum Expr {
     Try {
         expr: ExprId,
     },
+    TryBlock {
+        body: ExprId,
+    },
     Cast {
         expr: ExprId,
         type_ref: TypeRef,
@@ -236,6 +239,7 @@ impl Expr {
                     f(*expr);
                 }
             }
+            Expr::TryBlock { body } => f(*body),
             Expr::Loop { body } => f(*body),
             Expr::While { condition, body } => {
                 f(*condition);
diff --git a/crates/ra_hir_def/src/generics.rs b/crates/ra_hir_def/src/generics.rs
index d850244c4..09a5241f7 100644
--- a/crates/ra_hir_def/src/generics.rs
+++ b/crates/ra_hir_def/src/generics.rs
@@ -15,6 +15,7 @@ use ra_prof::profile;
 use ra_syntax::ast::{self, NameOwner, TypeBoundsOwner, TypeParamsOwner};
 
 use crate::{
+    body::LowerCtx,
     child_by_source::ChildBySource,
     db::DefDatabase,
     dyn_map::DynMap,
@@ -80,11 +81,13 @@ impl GenericParams {
     fn new(db: &dyn DefDatabase, def: GenericDefId) -> (GenericParams, InFile<SourceMap>) {
         let mut generics = GenericParams { types: Arena::default(), where_predicates: Vec::new() };
         let mut sm = ArenaMap::default();
+
         // FIXME: add `: Sized` bound for everything except for `Self` in traits
         let file_id = match def {
             GenericDefId::FunctionId(it) => {
                 let src = it.lookup(db).source(db);
-                generics.fill(&mut sm, &src.value);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+                generics.fill(&lower_ctx, &mut sm, &src.value);
                 // lower `impl Trait` in arguments
                 let data = db.function_data(it);
                 for param in &data.params {
@@ -94,21 +97,25 @@ impl GenericParams {
             }
             GenericDefId::AdtId(AdtId::StructId(it)) => {
                 let src = it.lookup(db).source(db);
-                generics.fill(&mut sm, &src.value);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+                generics.fill(&lower_ctx, &mut sm, &src.value);
                 src.file_id
             }
             GenericDefId::AdtId(AdtId::UnionId(it)) => {
                 let src = it.lookup(db).source(db);
-                generics.fill(&mut sm, &src.value);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+                generics.fill(&lower_ctx, &mut sm, &src.value);
                 src.file_id
             }
             GenericDefId::AdtId(AdtId::EnumId(it)) => {
                 let src = it.lookup(db).source(db);
-                generics.fill(&mut sm, &src.value);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+                generics.fill(&lower_ctx, &mut sm, &src.value);
                 src.file_id
             }
             GenericDefId::TraitId(it) => {
                 let src = it.lookup(db).source(db);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
 
                 // traits get the Self type as an implicit first type parameter
                 let self_param_id = generics.types.alloc(TypeParamData {
@@ -120,14 +127,16 @@ impl GenericParams {
                 // add super traits as bounds on Self
                 // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
                 let self_param = TypeRef::Path(name![Self].into());
-                generics.fill_bounds(&src.value, self_param);
+                generics.fill_bounds(&lower_ctx, &src.value, self_param);
 
-                generics.fill(&mut sm, &src.value);
+                generics.fill(&lower_ctx, &mut sm, &src.value);
                 src.file_id
             }
             GenericDefId::TypeAliasId(it) => {
                 let src = it.lookup(db).source(db);
-                generics.fill(&mut sm, &src.value);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+
+                generics.fill(&lower_ctx, &mut sm, &src.value);
                 src.file_id
             }
             // Note that we don't add `Self` here: in `impl`s, `Self` is not a
@@ -135,7 +144,9 @@ impl GenericParams {
             // type, so this is handled by the resolver.
             GenericDefId::ImplId(it) => {
                 let src = it.lookup(db).source(db);
-                generics.fill(&mut sm, &src.value);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+
+                generics.fill(&lower_ctx, &mut sm, &src.value);
                 src.file_id
             }
             // We won't be using this ID anyway
@@ -145,28 +156,38 @@ impl GenericParams {
         (generics, InFile::new(file_id, sm))
     }
 
-    fn fill(&mut self, sm: &mut SourceMap, node: &dyn TypeParamsOwner) {
+    fn fill(&mut self, lower_ctx: &LowerCtx, sm: &mut SourceMap, node: &dyn TypeParamsOwner) {
         if let Some(params) = node.type_param_list() {
-            self.fill_params(sm, params)
+            self.fill_params(lower_ctx, sm, params)
         }
         if let Some(where_clause) = node.where_clause() {
-            self.fill_where_predicates(where_clause);
+            self.fill_where_predicates(lower_ctx, where_clause);
         }
     }
 
-    fn fill_bounds(&mut self, node: &dyn ast::TypeBoundsOwner, type_ref: TypeRef) {
+    fn fill_bounds(
+        &mut self,
+        lower_ctx: &LowerCtx,
+        node: &dyn ast::TypeBoundsOwner,
+        type_ref: TypeRef,
+    ) {
         for bound in
             node.type_bound_list().iter().flat_map(|type_bound_list| type_bound_list.bounds())
         {
-            self.add_where_predicate_from_bound(bound, type_ref.clone());
+            self.add_where_predicate_from_bound(lower_ctx, bound, type_ref.clone());
         }
     }
 
-    fn fill_params(&mut self, sm: &mut SourceMap, params: ast::TypeParamList) {
+    fn fill_params(
+        &mut self,
+        lower_ctx: &LowerCtx,
+        sm: &mut SourceMap,
+        params: ast::TypeParamList,
+    ) {
         for type_param in params.type_params() {
             let name = type_param.name().map_or_else(Name::missing, |it| it.as_name());
             // FIXME: Use `Path::from_src`
-            let default = type_param.default_type().map(TypeRef::from_ast);
+            let default = type_param.default_type().map(|it| TypeRef::from_ast(lower_ctx, it));
             let param = TypeParamData {
                 name: Some(name.clone()),
                 default,
@@ -176,29 +197,34 @@ impl GenericParams {
             sm.insert(param_id, Either::Right(type_param.clone()));
 
             let type_ref = TypeRef::Path(name.into());
-            self.fill_bounds(&type_param, type_ref);
+            self.fill_bounds(&lower_ctx, &type_param, type_ref);
         }
     }
 
-    fn fill_where_predicates(&mut self, where_clause: ast::WhereClause) {
+    fn fill_where_predicates(&mut self, lower_ctx: &LowerCtx, where_clause: ast::WhereClause) {
         for pred in where_clause.predicates() {
             let type_ref = match pred.type_ref() {
                 Some(type_ref) => type_ref,
                 None => continue,
             };
-            let type_ref = TypeRef::from_ast(type_ref);
+            let type_ref = TypeRef::from_ast(lower_ctx, type_ref);
             for bound in pred.type_bound_list().iter().flat_map(|l| l.bounds()) {
-                self.add_where_predicate_from_bound(bound, type_ref.clone());
+                self.add_where_predicate_from_bound(lower_ctx, bound, type_ref.clone());
             }
         }
     }
 
-    fn add_where_predicate_from_bound(&mut self, bound: ast::TypeBound, type_ref: TypeRef) {
+    fn add_where_predicate_from_bound(
+        &mut self,
+        lower_ctx: &LowerCtx,
+        bound: ast::TypeBound,
+        type_ref: TypeRef,
+    ) {
         if bound.question_token().is_some() {
             // FIXME: remove this bound
             return;
         }
-        let bound = TypeBound::from_ast(bound);
+        let bound = TypeBound::from_ast(lower_ctx, bound);
         self.where_predicates
             .push(WherePredicate { target: WherePredicateTarget::TypeRef(type_ref), bound });
     }
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 98c74fe25..bf3968bd6 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -204,6 +204,7 @@ impl DefCollector<'_> {
                 ast_id: None,
                 krate: Some(krate),
                 kind: MacroDefKind::CustomDerive(expander),
+                local_inner: false,
             };
 
             self.define_proc_macro(name.clone(), macro_id);
@@ -941,6 +942,7 @@ impl ModCollector<'_, '_> {
                     ast_id: Some(ast_id.ast_id),
                     krate: Some(self.def_collector.def_map.krate),
                     kind: MacroDefKind::Declarative,
+                    local_inner: mac.local_inner,
                 };
                 self.def_collector.define_macro(self.module_id, name.clone(), macro_id, mac.export);
             }
diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs
index 39b011ad7..a71503c76 100644
--- a/crates/ra_hir_def/src/nameres/raw.rs
+++ b/crates/ra_hir_def/src/nameres/raw.rs
@@ -188,6 +188,7 @@ pub(super) struct MacroData {
     pub(super) path: ModPath,
     pub(super) name: Option<Name>,
     pub(super) export: bool,
+    pub(super) local_inner: bool,
     pub(super) builtin: bool,
 }
 
@@ -401,14 +402,32 @@ impl RawItemsCollector {
 
         let name = m.name().map(|it| it.as_name());
         let ast_id = self.source_ast_id_map.ast_id(&m);
-        // FIXME: cfg_attr
-        let export = m.attrs().filter_map(|x| x.simple_name()).any(|name| name == "macro_export");
 
         // FIXME: cfg_attr
-        let builtin =
-            m.attrs().filter_map(|x| x.simple_name()).any(|name| name == "rustc_builtin_macro");
+        let export_attr = attrs.by_key("macro_export");
+
+        let export = export_attr.exists();
+        let local_inner = if export {
+            export_attr.tt_values().map(|it| &it.token_trees).flatten().any(|it| match it {
+                tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => {
+                    ident.text.contains("local_inner_macros")
+                }
+                _ => false,
+            })
+        } else {
+            false
+        };
+
+        let builtin = attrs.by_key("rustc_builtin_macro").exists();
 
-        let m = self.raw_items.macros.alloc(MacroData { ast_id, path, name, export, builtin });
+        let m = self.raw_items.macros.alloc(MacroData {
+            ast_id,
+            path,
+            name,
+            export,
+            local_inner,
+            builtin,
+        });
         self.push_item(current_module, attrs, RawItemKind::Macro(m));
     }
 
diff --git a/crates/ra_hir_def/src/nameres/tests/macros.rs b/crates/ra_hir_def/src/nameres/tests/macros.rs
index b0befdfbd..9bc0e6287 100644
--- a/crates/ra_hir_def/src/nameres/tests/macros.rs
+++ b/crates/ra_hir_def/src/nameres/tests/macros.rs
@@ -136,6 +136,43 @@ fn macro_rules_export_with_local_inner_macros_are_visible() {
 }
 
 #[test]
+fn local_inner_macros_makes_local_macros_usable() {
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:foo
+        foo::structs!(Foo, Bar);
+        mod bar;
+        //- /bar.rs
+        use crate::*;
+        //- /lib.rs crate:foo
+        #[macro_export(local_inner_macros)]
+        macro_rules! structs {
+            ($($i:ident),*) => {
+                inner!($($i),*);
+            }
+        }
+        #[macro_export]
+        macro_rules! inner {
+            ($($i:ident),*) => {
+                $(struct $i { field: u32 } )*
+            }
+        }
+        ",
+    );
+    assert_snapshot!(map, @r###"
+   ⋮crate
+   ⋮Bar: t v
+   ⋮Foo: t v
+   ⋮bar: t
+   ⋮
+   ⋮crate::bar
+   ⋮Bar: t v
+   ⋮Foo: t v
+   ⋮bar: t
+    "###);
+}
+
+#[test]
 fn unexpanded_macro_should_expand_by_fixedpoint_loop() {
     let map = def_map(
         "
diff --git a/crates/ra_hir_def/src/path.rs b/crates/ra_hir_def/src/path.rs
index 162b3c8c7..e84efe2ab 100644
--- a/crates/ra_hir_def/src/path.rs
+++ b/crates/ra_hir_def/src/path.rs
@@ -7,6 +7,7 @@ use std::{
     sync::Arc,
 };
 
+use crate::body::LowerCtx;
 use hir_expand::{
     hygiene::Hygiene,
     name::{AsName, Name},
@@ -244,8 +245,8 @@ impl<'a> PathSegments<'a> {
 }
 
 impl GenericArgs {
-    pub(crate) fn from_ast(node: ast::TypeArgList) -> Option<GenericArgs> {
-        lower::lower_generic_args(node)
+    pub(crate) fn from_ast(lower_ctx: &LowerCtx, node: ast::TypeArgList) -> Option<GenericArgs> {
+        lower::lower_generic_args(lower_ctx, node)
     }
 
     pub(crate) fn empty() -> GenericArgs {
diff --git a/crates/ra_hir_def/src/path/lower.rs b/crates/ra_hir_def/src/path/lower.rs
index 9ec2e0dcd..6a0c019fd 100644
--- a/crates/ra_hir_def/src/path/lower.rs
+++ b/crates/ra_hir_def/src/path/lower.rs
@@ -13,6 +13,7 @@ use ra_syntax::ast::{self, AstNode, TypeAscriptionOwner, TypeBoundsOwner};
 
 use super::AssociatedTypeBinding;
 use crate::{
+    body::LowerCtx,
     path::{GenericArg, GenericArgs, ModPath, Path, PathKind},
     type_ref::{TypeBound, TypeRef},
 };
@@ -26,6 +27,7 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
     let mut type_anchor = None;
     let mut segments = Vec::new();
     let mut generic_args = Vec::new();
+    let ctx = LowerCtx::with_hygiene(hygiene);
     loop {
         let segment = path.segment()?;
 
@@ -40,9 +42,10 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
                     Either::Left(name) => {
                         let args = segment
                             .type_arg_list()
-                            .and_then(lower_generic_args)
+                            .and_then(|it| lower_generic_args(&ctx, it))
                             .or_else(|| {
                                 lower_generic_args_from_fn_path(
+                                    &ctx,
                                     segment.param_list(),
                                     segment.ret_type(),
                                 )
@@ -60,7 +63,7 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
             ast::PathSegmentKind::Type { type_ref, trait_ref } => {
                 assert!(path.qualifier().is_none()); // this can only occur at the first segment
 
-                let self_type = TypeRef::from_ast(type_ref?);
+                let self_type = TypeRef::from_ast(&ctx, type_ref?);
 
                 match trait_ref {
                     // <T>::foo
@@ -113,6 +116,21 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
     }
     segments.reverse();
     generic_args.reverse();
+
+    // handle local_inner_macros :
+    // Basically, even in rustc it is quite hacky:
+    // https://github.com/rust-lang/rust/blob/614f273e9388ddd7804d5cbc80b8865068a3744e/src/librustc_resolve/macros.rs#L456
+    // We follow what it did anyway :)
+    if segments.len() == 1 && kind == PathKind::Plain {
+        if let Some(macro_call) = path.syntax().parent().and_then(ast::MacroCall::cast) {
+            if macro_call.is_bang() {
+                if let Some(crate_id) = hygiene.local_inner_macros() {
+                    kind = PathKind::DollarCrate(crate_id);
+                }
+            }
+        }
+    }
+
     let mod_path = ModPath { kind, segments };
     return Some(Path { type_anchor, mod_path, generic_args });
 
@@ -128,10 +146,13 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
     }
 }
 
-pub(super) fn lower_generic_args(node: ast::TypeArgList) -> Option<GenericArgs> {
+pub(super) fn lower_generic_args(
+    lower_ctx: &LowerCtx,
+    node: ast::TypeArgList,
+) -> Option<GenericArgs> {
     let mut args = Vec::new();
     for type_arg in node.type_args() {
-        let type_ref = TypeRef::from_ast_opt(type_arg.type_ref());
+        let type_ref = TypeRef::from_ast_opt(lower_ctx, type_arg.type_ref());
         args.push(GenericArg::Type(type_ref));
     }
     // lifetimes ignored for now
@@ -140,9 +161,9 @@ pub(super) fn lower_generic_args(node: ast::TypeArgList) -> Option<GenericArgs>
         let assoc_type_arg: ast::AssocTypeArg = assoc_type_arg;
         if let Some(name_ref) = assoc_type_arg.name_ref() {
             let name = name_ref.as_name();
-            let type_ref = assoc_type_arg.type_ref().map(TypeRef::from_ast);
+            let type_ref = assoc_type_arg.type_ref().map(|it| TypeRef::from_ast(lower_ctx, it));
             let bounds = if let Some(l) = assoc_type_arg.type_bound_list() {
-                l.bounds().map(TypeBound::from_ast).collect()
+                l.bounds().map(|it| TypeBound::from_ast(lower_ctx, it)).collect()
             } else {
                 Vec::new()
             };
@@ -159,6 +180,7 @@ pub(super) fn lower_generic_args(node: ast::TypeArgList) -> Option<GenericArgs>
 /// Collect `GenericArgs` from the parts of a fn-like path, i.e. `Fn(X, Y)
 /// -> Z` (which desugars to `Fn<(X, Y), Output=Z>`).
 fn lower_generic_args_from_fn_path(
+    ctx: &LowerCtx,
     params: Option<ast::ParamList>,
     ret_type: Option<ast::RetType>,
 ) -> Option<GenericArgs> {
@@ -167,14 +189,14 @@ fn lower_generic_args_from_fn_path(
     if let Some(params) = params {
         let mut param_types = Vec::new();
         for param in params.params() {
-            let type_ref = TypeRef::from_ast_opt(param.ascribed_type());
+            let type_ref = TypeRef::from_ast_opt(&ctx, param.ascribed_type());
             param_types.push(type_ref);
         }
         let arg = GenericArg::Type(TypeRef::Tuple(param_types));
         args.push(arg);
     }
     if let Some(ret_type) = ret_type {
-        let type_ref = TypeRef::from_ast_opt(ret_type.type_ref());
+        let type_ref = TypeRef::from_ast_opt(&ctx, ret_type.type_ref());
         bindings.push(AssociatedTypeBinding {
             name: name![Output],
             type_ref: Some(type_ref),
diff --git a/crates/ra_hir_def/src/type_ref.rs b/crates/ra_hir_def/src/type_ref.rs
index f308c6bdf..5bdad9efd 100644
--- a/crates/ra_hir_def/src/type_ref.rs
+++ b/crates/ra_hir_def/src/type_ref.rs
@@ -3,7 +3,7 @@
 
 use ra_syntax::ast::{self, TypeAscriptionOwner, TypeBoundsOwner};
 
-use crate::path::Path;
+use crate::{body::LowerCtx, path::Path};
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 pub enum Mutability {
@@ -64,30 +64,34 @@ pub enum TypeBound {
 
 impl TypeRef {
     /// Converts an `ast::TypeRef` to a `hir::TypeRef`.
-    pub(crate) fn from_ast(node: ast::TypeRef) -> Self {
+    pub(crate) fn from_ast(ctx: &LowerCtx, node: ast::TypeRef) -> Self {
         match node {
-            ast::TypeRef::ParenType(inner) => TypeRef::from_ast_opt(inner.type_ref()),
+            ast::TypeRef::ParenType(inner) => TypeRef::from_ast_opt(&ctx, inner.type_ref()),
             ast::TypeRef::TupleType(inner) => {
-                TypeRef::Tuple(inner.fields().map(TypeRef::from_ast).collect())
+                TypeRef::Tuple(inner.fields().map(|it| TypeRef::from_ast(ctx, it)).collect())
             }
             ast::TypeRef::NeverType(..) => TypeRef::Never,
             ast::TypeRef::PathType(inner) => {
                 // FIXME: Use `Path::from_src`
-                inner.path().and_then(Path::from_ast).map(TypeRef::Path).unwrap_or(TypeRef::Error)
+                inner
+                    .path()
+                    .and_then(|it| ctx.lower_path(it))
+                    .map(TypeRef::Path)
+                    .unwrap_or(TypeRef::Error)
             }
             ast::TypeRef::PointerType(inner) => {
-                let inner_ty = TypeRef::from_ast_opt(inner.type_ref());
+                let inner_ty = TypeRef::from_ast_opt(&ctx, inner.type_ref());
                 let mutability = Mutability::from_mutable(inner.mut_token().is_some());
                 TypeRef::RawPtr(Box::new(inner_ty), mutability)
             }
             ast::TypeRef::ArrayType(inner) => {
-                TypeRef::Array(Box::new(TypeRef::from_ast_opt(inner.type_ref())))
+                TypeRef::Array(Box::new(TypeRef::from_ast_opt(&ctx, inner.type_ref())))
             }
             ast::TypeRef::SliceType(inner) => {
-                TypeRef::Slice(Box::new(TypeRef::from_ast_opt(inner.type_ref())))
+                TypeRef::Slice(Box::new(TypeRef::from_ast_opt(&ctx, inner.type_ref())))
             }
             ast::TypeRef::ReferenceType(inner) => {
-                let inner_ty = TypeRef::from_ast_opt(inner.type_ref());
+                let inner_ty = TypeRef::from_ast_opt(&ctx, inner.type_ref());
                 let mutability = Mutability::from_mutable(inner.mut_token().is_some());
                 TypeRef::Reference(Box::new(inner_ty), mutability)
             }
@@ -96,10 +100,13 @@ impl TypeRef {
                 let ret_ty = inner
                     .ret_type()
                     .and_then(|rt| rt.type_ref())
-                    .map(TypeRef::from_ast)
+                    .map(|it| TypeRef::from_ast(ctx, it))
                     .unwrap_or_else(|| TypeRef::Tuple(Vec::new()));
                 let mut params = if let Some(pl) = inner.param_list() {
-                    pl.params().map(|p| p.ascribed_type()).map(TypeRef::from_ast_opt).collect()
+                    pl.params()
+                        .map(|p| p.ascribed_type())
+                        .map(|it| TypeRef::from_ast_opt(&ctx, it))
+                        .collect()
                 } else {
                     Vec::new()
                 };
@@ -107,19 +114,19 @@ impl TypeRef {
                 TypeRef::Fn(params)
             }
             // for types are close enough for our purposes to the inner type for now...
-            ast::TypeRef::ForType(inner) => TypeRef::from_ast_opt(inner.type_ref()),
+            ast::TypeRef::ForType(inner) => TypeRef::from_ast_opt(&ctx, inner.type_ref()),
             ast::TypeRef::ImplTraitType(inner) => {
-                TypeRef::ImplTrait(type_bounds_from_ast(inner.type_bound_list()))
+                TypeRef::ImplTrait(type_bounds_from_ast(ctx, inner.type_bound_list()))
             }
             ast::TypeRef::DynTraitType(inner) => {
-                TypeRef::DynTrait(type_bounds_from_ast(inner.type_bound_list()))
+                TypeRef::DynTrait(type_bounds_from_ast(ctx, inner.type_bound_list()))
             }
         }
     }
 
-    pub(crate) fn from_ast_opt(node: Option<ast::TypeRef>) -> Self {
+    pub(crate) fn from_ast_opt(ctx: &LowerCtx, node: Option<ast::TypeRef>) -> Self {
         if let Some(node) = node {
-            TypeRef::from_ast(node)
+            TypeRef::from_ast(ctx, node)
         } else {
             TypeRef::Error
         }
@@ -180,24 +187,27 @@ impl TypeRef {
     }
 }
 
-pub(crate) fn type_bounds_from_ast(type_bounds_opt: Option<ast::TypeBoundList>) -> Vec<TypeBound> {
+pub(crate) fn type_bounds_from_ast(
+    lower_ctx: &LowerCtx,
+    type_bounds_opt: Option<ast::TypeBoundList>,
+) -> Vec<TypeBound> {
     if let Some(type_bounds) = type_bounds_opt {
-        type_bounds.bounds().map(TypeBound::from_ast).collect()
+        type_bounds.bounds().map(|it| TypeBound::from_ast(lower_ctx, it)).collect()
     } else {
         vec![]
     }
 }
 
 impl TypeBound {
-    pub(crate) fn from_ast(node: ast::TypeBound) -> Self {
+    pub(crate) fn from_ast(ctx: &LowerCtx, node: ast::TypeBound) -> Self {
         match node.kind() {
             ast::TypeBoundKind::PathType(path_type) => {
                 let path = match path_type.path() {
                     Some(p) => p,
                     None => return TypeBound::Error,
                 };
-                // FIXME: Use `Path::from_src`
-                let path = match Path::from_ast(path) {
+
+                let path = match ctx.lower_path(path) {
                     Some(p) => p,
                     None => return TypeBound::Error,
                 };
diff --git a/crates/ra_hir_expand/src/builtin_derive.rs b/crates/ra_hir_expand/src/builtin_derive.rs
index e60f879a3..1dc9cac66 100644
--- a/crates/ra_hir_expand/src/builtin_derive.rs
+++ b/crates/ra_hir_expand/src/builtin_derive.rs
@@ -38,7 +38,7 @@ macro_rules! register_builtin {
                  _ => return None,
             };
 
-            Some(MacroDefId { krate: None, ast_id: None, kind: MacroDefKind::BuiltInDerive(kind) })
+            Some(MacroDefId { krate: None, ast_id: None, kind: MacroDefKind::BuiltInDerive(kind), local_inner: false })
         }
     };
 }
diff --git a/crates/ra_hir_expand/src/builtin_macro.rs b/crates/ra_hir_expand/src/builtin_macro.rs
index e0fef613d..d8b3d342c 100644
--- a/crates/ra_hir_expand/src/builtin_macro.rs
+++ b/crates/ra_hir_expand/src/builtin_macro.rs
@@ -73,11 +73,13 @@ pub fn find_builtin_macro(
             krate: Some(krate),
             ast_id: Some(ast_id),
             kind: MacroDefKind::BuiltIn(kind),
+            local_inner: false,
         }),
         Either::Right(kind) => Some(MacroDefId {
             krate: Some(krate),
             ast_id: Some(ast_id),
             kind: MacroDefKind::BuiltInEager(kind),
+            local_inner: false,
         }),
     }
 }
@@ -406,6 +408,7 @@ mod tests {
                     krate: Some(CrateId(0)),
                     ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_calls[0]))),
                     kind: MacroDefKind::BuiltIn(expander),
+                    local_inner: false,
                 };
 
                 let loc = MacroCallLoc {
@@ -425,6 +428,7 @@ mod tests {
                     krate: Some(CrateId(0)),
                     ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_calls[0]))),
                     kind: MacroDefKind::BuiltInEager(expander),
+                    local_inner: false,
                 };
 
                 let args = macro_calls[1].token_tree().unwrap();
diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs
index 047452306..4c12d0a15 100644
--- a/crates/ra_hir_expand/src/db.rs
+++ b/crates/ra_hir_expand/src/db.rs
@@ -330,7 +330,7 @@ fn to_fragment_kind(db: &dyn AstDatabase, id: MacroCallId) -> FragmentKind {
             FragmentKind::Expr
         }
         // FIXME: Expand to statements in appropriate positions; HIR lowering needs to handle that
-        EXPR_STMT | BLOCK => FragmentKind::Expr,
+        EXPR_STMT | BLOCK_EXPR => FragmentKind::Expr,
         ARG_LIST => FragmentKind::Expr,
         TRY_EXPR => FragmentKind::Expr,
         TUPLE_EXPR => FragmentKind::Expr,
@@ -342,7 +342,6 @@ fn to_fragment_kind(db: &dyn AstDatabase, id: MacroCallId) -> FragmentKind {
         CONDITION => FragmentKind::Expr,
         BREAK_EXPR => FragmentKind::Expr,
         RETURN_EXPR => FragmentKind::Expr,
-        BLOCK_EXPR => FragmentKind::Expr,
         MATCH_EXPR => FragmentKind::Expr,
         MATCH_ARM => FragmentKind::Expr,
         MATCH_GUARD => FragmentKind::Expr,
diff --git a/crates/ra_hir_expand/src/hygiene.rs b/crates/ra_hir_expand/src/hygiene.rs
index 0b41d0e95..6b482a60c 100644
--- a/crates/ra_hir_expand/src/hygiene.rs
+++ b/crates/ra_hir_expand/src/hygiene.rs
@@ -12,35 +12,38 @@ use crate::{
     HirFileId, HirFileIdRepr, MacroCallId, MacroDefKind,
 };
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Hygiene {
     // This is what `$crate` expands to
     def_crate: Option<CrateId>,
+
+    // Indiciate this is a local inner macro
+    local_inner: bool,
 }
 
 impl Hygiene {
     pub fn new(db: &dyn AstDatabase, file_id: HirFileId) -> Hygiene {
-        let def_crate = match file_id.0 {
-            HirFileIdRepr::FileId(_) => None,
+        let (def_crate, local_inner) = match file_id.0 {
+            HirFileIdRepr::FileId(_) => (None, false),
             HirFileIdRepr::MacroFile(macro_file) => match macro_file.macro_call_id {
                 MacroCallId::LazyMacro(id) => {
                     let loc = db.lookup_intern_macro(id);
                     match loc.def.kind {
-                        MacroDefKind::Declarative => loc.def.krate,
-                        MacroDefKind::BuiltIn(_) => None,
-                        MacroDefKind::BuiltInDerive(_) => None,
-                        MacroDefKind::BuiltInEager(_) => None,
-                        MacroDefKind::CustomDerive(_) => None,
+                        MacroDefKind::Declarative => (loc.def.krate, loc.def.local_inner),
+                        MacroDefKind::BuiltIn(_) => (None, false),
+                        MacroDefKind::BuiltInDerive(_) => (None, false),
+                        MacroDefKind::BuiltInEager(_) => (None, false),
+                        MacroDefKind::CustomDerive(_) => (None, false),
                     }
                 }
-                MacroCallId::EagerMacro(_id) => None,
+                MacroCallId::EagerMacro(_id) => (None, false),
             },
         };
-        Hygiene { def_crate }
+        Hygiene { def_crate, local_inner }
     }
 
     pub fn new_unhygienic() -> Hygiene {
-        Hygiene { def_crate: None }
+        Hygiene { def_crate: None, local_inner: false }
     }
 
     // FIXME: this should just return name
@@ -52,4 +55,12 @@ impl Hygiene {
         }
         Either::Left(name_ref.as_name())
     }
+
+    pub fn local_inner_macros(&self) -> Option<CrateId> {
+        if self.local_inner {
+            self.def_crate
+        } else {
+            None
+        }
+    }
 }
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 754a0f005..f440c073b 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -204,6 +204,8 @@ pub struct MacroDefId {
     pub krate: Option<CrateId>,
     pub ast_id: Option<AstId<ast::MacroCall>>,
     pub kind: MacroDefKind,
+
+    pub local_inner: bool,
 }
 
 impl MacroDefId {
diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs
index efc60986b..83f946eee 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -73,6 +73,11 @@ impl<'a> InferenceContext<'a> {
                 self.coerce_merge_branch(&then_ty, &else_ty)
             }
             Expr::Block { statements, tail } => self.infer_block(statements, *tail, expected),
+            Expr::TryBlock { body } => {
+                let _inner = self.infer_expr(*body, expected);
+                // FIXME should be std::result::Result<{inner}, _>
+                Ty::Unknown
+            }
             Expr::Loop { body } => {
                 self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
                 // FIXME handle break with value
diff --git a/crates/ra_hir_ty/src/tests/macros.rs b/crates/ra_hir_ty/src/tests/macros.rs
index 5ddecbdc6..29e38a06c 100644
--- a/crates/ra_hir_ty/src/tests/macros.rs
+++ b/crates/ra_hir_ty/src/tests/macros.rs
@@ -339,6 +339,46 @@ pub fn baz() -> usize { 31usize }
 }
 
 #[test]
+fn infer_macro_with_dollar_crate_is_correct_in_trait_associate_type() {
+    let (db, pos) = TestDB::with_position(
+        r#"
+//- /main.rs crate:main deps:foo
+use foo::Trait;
+
+fn test() {
+    let msg = foo::Message(foo::MessageRef);
+    let r = msg.deref();
+    r<|>;
+}
+
+//- /lib.rs crate:foo
+pub struct MessageRef;
+pub struct Message(MessageRef);
+
+pub trait Trait {
+    type Target;
+    fn deref(&self) -> &Self::Target;
+}
+
+#[macro_export]
+macro_rules! expand {
+    () => {
+        impl Trait for Message {
+            type Target = $crate::MessageRef;
+            fn deref(&self) ->  &Self::Target {
+                &self.0
+            }
+        }
+    }
+}
+
+expand!();
+"#,
+    );
+    assert_eq!("&MessageRef", type_at_pos(&db, pos));
+}
+
+#[test]
 fn infer_type_value_non_legacy_macro_use_as() {
     assert_snapshot!(
         infer(r#"
@@ -388,6 +428,32 @@ fn main() {
 }
 
 #[test]
+fn infer_local_inner_macros() {
+    let (db, pos) = TestDB::with_position(
+        r#"
+//- /main.rs crate:main deps:foo
+fn test() {
+    let x = foo::foo!(1);
+    x<|>;
+}
+
+//- /lib.rs crate:foo
+#[macro_export(local_inner_macros)]
+macro_rules! foo {
+    (1) => { bar!() };
+}
+
+#[macro_export]
+macro_rules! bar {
+    () => { 42 }
+}
+
+"#,
+    );
+    assert_eq!("i32", type_at_pos(&db, pos));
+}
+
+#[test]
 fn infer_builtin_macros_line() {
     assert_snapshot!(
         infer(r#"
diff --git a/crates/ra_hir_ty/src/tests/simple.rs b/crates/ra_hir_ty/src/tests/simple.rs
index 56abc65b8..3d3088965 100644
--- a/crates/ra_hir_ty/src/tests/simple.rs
+++ b/crates/ra_hir_ty/src/tests/simple.rs
@@ -1755,3 +1755,35 @@ fn main() {
     "###
     );
 }
+
+#[test]
+fn effects_smoke_test() {
+    assert_snapshot!(
+        infer(r#"
+fn main() {
+    let x = unsafe { 92 };
+    let y = async { async { () }.await };
+    let z = try { () };
+    let t = 'a: { 92 };
+}
+"#),
+        @r###"
+    11..131 '{     ...2 }; }': ()
+    21..22 'x': i32
+    32..38 '{ 92 }': i32
+    34..36 '92': i32
+    48..49 'y': {unknown}
+    58..80 '{ asyn...wait }': {unknown}
+    60..78 'async ....await': {unknown}
+    66..72 '{ () }': ()
+    68..70 '()': ()
+    90..91 'z': {unknown}
+    94..104 'try { () }': {unknown}
+    98..104 '{ () }': ()
+    100..102 '()': ()
+    114..115 't': i32
+    122..128 '{ 92 }': i32
+    124..126 '92': i32
+    "###
+    )
+}
diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index 4ca0fdf4f..a0e06faa2 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -65,21 +65,23 @@ pub(crate) fn completions(
     let ctx = CompletionContext::new(db, position, config)?;
 
     let mut acc = Completions::default();
-
-    complete_fn_param::complete_fn_param(&mut acc, &ctx);
-    complete_keyword::complete_expr_keyword(&mut acc, &ctx);
-    complete_keyword::complete_use_tree_keyword(&mut acc, &ctx);
-    complete_snippet::complete_expr_snippet(&mut acc, &ctx);
-    complete_snippet::complete_item_snippet(&mut acc, &ctx);
-    complete_qualified_path::complete_qualified_path(&mut acc, &ctx);
-    complete_unqualified_path::complete_unqualified_path(&mut acc, &ctx);
-    complete_dot::complete_dot(&mut acc, &ctx);
-    complete_record::complete_record(&mut acc, &ctx);
-    complete_pattern::complete_pattern(&mut acc, &ctx);
-    complete_postfix::complete_postfix(&mut acc, &ctx);
-    complete_macro_in_item_position::complete_macro_in_item_position(&mut acc, &ctx);
-    complete_trait_impl::complete_trait_impl(&mut acc, &ctx);
-    complete_attribute::complete_attribute(&mut acc, &ctx);
+    if ctx.attribute_under_caret.is_some() {
+        complete_attribute::complete_attribute(&mut acc, &ctx);
+    } else {
+        complete_fn_param::complete_fn_param(&mut acc, &ctx);
+        complete_keyword::complete_expr_keyword(&mut acc, &ctx);
+        complete_keyword::complete_use_tree_keyword(&mut acc, &ctx);
+        complete_snippet::complete_expr_snippet(&mut acc, &ctx);
+        complete_snippet::complete_item_snippet(&mut acc, &ctx);
+        complete_qualified_path::complete_qualified_path(&mut acc, &ctx);
+        complete_unqualified_path::complete_unqualified_path(&mut acc, &ctx);
+        complete_dot::complete_dot(&mut acc, &ctx);
+        complete_record::complete_record(&mut acc, &ctx);
+        complete_pattern::complete_pattern(&mut acc, &ctx);
+        complete_postfix::complete_postfix(&mut acc, &ctx);
+        complete_macro_in_item_position::complete_macro_in_item_position(&mut acc, &ctx);
+        complete_trait_impl::complete_trait_impl(&mut acc, &ctx);
+    }
 
     Some(acc)
 }
diff --git a/crates/ra_ide/src/completion/complete_attribute.rs b/crates/ra_ide/src/completion/complete_attribute.rs
index 8bf952798..20e6edc17 100644
--- a/crates/ra_ide/src/completion/complete_attribute.rs
+++ b/crates/ra_ide/src/completion/complete_attribute.rs
@@ -5,23 +5,26 @@
 
 use super::completion_context::CompletionContext;
 use super::completion_item::{CompletionItem, CompletionItemKind, CompletionKind, Completions};
+use ast::AttrInput;
 use ra_syntax::{
-    ast::{Attr, AttrKind},
-    AstNode,
+    ast::{self, AttrKind},
+    AstNode, SyntaxKind,
 };
+use rustc_hash::FxHashSet;
 
-pub(super) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.is_attribute {
-        return;
-    }
+pub(super) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
+    let attribute = ctx.attribute_under_caret.as_ref()?;
 
-    let is_inner = ctx
-        .original_token
-        .ancestors()
-        .find_map(Attr::cast)
-        .map(|attr| attr.kind() == AttrKind::Inner)
-        .unwrap_or(false);
+    match (attribute.path(), attribute.input()) {
+        (Some(path), Some(AttrInput::TokenTree(token_tree))) if path.to_string() == "derive" => {
+            complete_derive(acc, ctx, token_tree)
+        }
+        _ => complete_attribute_start(acc, ctx, attribute),
+    }
+    Some(())
+}
 
+fn complete_attribute_start(acc: &mut Completions, ctx: &CompletionContext, attribute: &ast::Attr) {
     for attr_completion in ATTRIBUTES {
         let mut item = CompletionItem::new(
             CompletionKind::Attribute,
@@ -37,7 +40,7 @@ pub(super) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext)
             _ => {}
         }
 
-        if is_inner || !attr_completion.should_be_inner {
+        if attribute.kind() == AttrKind::Inner || !attr_completion.should_be_inner {
             acc.add(item);
         }
     }
@@ -126,6 +129,106 @@ const ATTRIBUTES: &[AttrCompletion] = &[
     },
 ];
 
+fn complete_derive(acc: &mut Completions, ctx: &CompletionContext, derive_input: ast::TokenTree) {
+    if let Ok(existing_derives) = parse_derive_input(derive_input) {
+        for derive_completion in DEFAULT_DERIVE_COMPLETIONS
+            .into_iter()
+            .filter(|completion| !existing_derives.contains(completion.label))
+        {
+            let mut label = derive_completion.label.to_owned();
+            for dependency in derive_completion
+                .dependencies
+                .into_iter()
+                .filter(|&&dependency| !existing_derives.contains(dependency))
+            {
+                label.push_str(", ");
+                label.push_str(dependency);
+            }
+            acc.add(
+                CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), label)
+                    .kind(CompletionItemKind::Attribute),
+            );
+        }
+
+        for custom_derive_name in get_derive_names_in_scope(ctx).difference(&existing_derives) {
+            acc.add(
+                CompletionItem::new(
+                    CompletionKind::Attribute,
+                    ctx.source_range(),
+                    custom_derive_name,
+                )
+                .kind(CompletionItemKind::Attribute),
+            );
+        }
+    }
+}
+
+fn parse_derive_input(derive_input: ast::TokenTree) -> Result<FxHashSet<String>, ()> {
+    match (derive_input.left_delimiter_token(), derive_input.right_delimiter_token()) {
+        (Some(left_paren), Some(right_paren))
+            if left_paren.kind() == SyntaxKind::L_PAREN
+                && right_paren.kind() == SyntaxKind::R_PAREN =>
+        {
+            let mut input_derives = FxHashSet::default();
+            let mut current_derive = String::new();
+            for token in derive_input
+                .syntax()
+                .children_with_tokens()
+                .filter_map(|token| token.into_token())
+                .skip_while(|token| token != &left_paren)
+                .skip(1)
+                .take_while(|token| token != &right_paren)
+            {
+                if SyntaxKind::COMMA == token.kind() {
+                    if !current_derive.is_empty() {
+                        input_derives.insert(current_derive);
+                        current_derive = String::new();
+                    }
+                } else {
+                    current_derive.push_str(token.to_string().trim());
+                }
+            }
+
+            if !current_derive.is_empty() {
+                input_derives.insert(current_derive);
+            }
+            Ok(input_derives)
+        }
+        _ => Err(()),
+    }
+}
+
+fn get_derive_names_in_scope(ctx: &CompletionContext) -> FxHashSet<String> {
+    let mut result = FxHashSet::default();
+    ctx.scope().process_all_names(&mut |name, scope_def| {
+        if let hir::ScopeDef::MacroDef(mac) = scope_def {
+            if mac.is_derive_macro() {
+                result.insert(name.to_string());
+            }
+        }
+    });
+    result
+}
+
+struct DeriveCompletion {
+    label: &'static str,
+    dependencies: &'static [&'static str],
+}
+
+/// Standard Rust derives and the information about their dependencies
+/// (the dependencies are needed so that the main derive don't break the compilation when added)
+const DEFAULT_DERIVE_COMPLETIONS: &[DeriveCompletion] = &[
+    DeriveCompletion { label: "Clone", dependencies: &[] },
+    DeriveCompletion { label: "Copy", dependencies: &["Clone"] },
+    DeriveCompletion { label: "Debug", dependencies: &[] },
+    DeriveCompletion { label: "Default", dependencies: &[] },
+    DeriveCompletion { label: "Hash", dependencies: &[] },
+    DeriveCompletion { label: "PartialEq", dependencies: &[] },
+    DeriveCompletion { label: "Eq", dependencies: &["PartialEq"] },
+    DeriveCompletion { label: "PartialOrd", dependencies: &["PartialEq"] },
+    DeriveCompletion { label: "Ord", dependencies: &["PartialOrd", "Eq", "PartialEq"] },
+];
+
 #[cfg(test)]
 mod tests {
     use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
@@ -136,6 +239,170 @@ mod tests {
     }
 
     #[test]
+    fn empty_derive_completion() {
+        assert_debug_snapshot!(
+            do_attr_completion(
+                    r"
+                    #[derive(<|>)]
+                    struct Test {}
+                    ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Clone",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Clone",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Copy, Clone",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Copy, Clone",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Debug",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Debug",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Default",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Default",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Eq, PartialEq",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Eq, PartialEq",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Hash",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Hash",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Ord, PartialOrd, Eq, PartialEq",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Ord, PartialOrd, Eq, PartialEq",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "PartialEq",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "PartialEq",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "PartialOrd, PartialEq",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "PartialOrd, PartialEq",
+                kind: Attribute,
+            },
+        ]
+            "###
+        );
+    }
+
+    #[test]
+    fn no_completion_for_incorrect_derive() {
+        assert_debug_snapshot!(
+            do_attr_completion(
+                r"
+                    #[derive{<|>)]
+                    struct Test {}
+                    ",
+            ),
+            @"[]"
+        );
+    }
+
+    #[test]
+    fn derive_with_input_completion() {
+        assert_debug_snapshot!(
+            do_attr_completion(
+                    r"
+                    #[derive(serde::Serialize, PartialEq, <|>)]
+                    struct Test {}
+                    ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Clone",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Clone",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Copy, Clone",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Copy, Clone",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Debug",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Debug",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Default",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Default",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Eq",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Eq",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Hash",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Hash",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Ord, PartialOrd, Eq",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Ord, PartialOrd, Eq",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "PartialOrd",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "PartialOrd",
+                kind: Attribute,
+            },
+        ]
+            "###
+        );
+    }
+
+    #[test]
     fn test_attribute_completion() {
         assert_debug_snapshot!(
         do_attr_completion(
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 118fceb2e..dd87bd119 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -58,7 +58,7 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) is_macro_call: bool,
     pub(super) is_path_type: bool,
     pub(super) has_type_args: bool,
-    pub(super) is_attribute: bool,
+    pub(super) attribute_under_caret: Option<ast::Attr>,
 }
 
 impl<'a> CompletionContext<'a> {
@@ -116,7 +116,7 @@ impl<'a> CompletionContext<'a> {
             is_path_type: false,
             has_type_args: false,
             dot_receiver_is_ambiguous_float_literal: false,
-            is_attribute: false,
+            attribute_under_caret: None,
         };
 
         let mut original_file = original_file.syntax().clone();
@@ -200,6 +200,7 @@ impl<'a> CompletionContext<'a> {
                 Some(ty)
             })
             .flatten();
+        self.attribute_under_caret = find_node_at_offset(&file_with_fake_ident, offset);
 
         // First, let's try to complete a reference to some declaration.
         if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(&file_with_fake_ident, offset) {
@@ -318,7 +319,6 @@ impl<'a> CompletionContext<'a> {
                 .and_then(|it| it.syntax().parent().and_then(ast::CallExpr::cast))
                 .is_some();
             self.is_macro_call = path.syntax().parent().and_then(ast::MacroCall::cast).is_some();
-            self.is_attribute = path.syntax().parent().and_then(ast::Attr::cast).is_some();
 
             self.is_path_type = path.syntax().parent().and_then(ast::PathType::cast).is_some();
             self.has_type_args = segment.type_arg_list().is_some();
@@ -344,7 +344,7 @@ impl<'a> CompletionContext<'a> {
                                 stmt.syntax().text_range() == name_ref.syntax().text_range(),
                             );
                         }
-                        if let Some(block) = ast::Block::cast(node) {
+                        if let Some(block) = ast::BlockExpr::cast(node) {
                             return Some(
                                 block.expr().map(|e| e.syntax().text_range())
                                     == Some(name_ref.syntax().text_range()),
diff --git a/crates/ra_ide/src/display/short_label.rs b/crates/ra_ide/src/display/short_label.rs
index 4b081bf6c..d37260e96 100644
--- a/crates/ra_ide/src/display/short_label.rs
+++ b/crates/ra_ide/src/display/short_label.rs
@@ -33,7 +33,11 @@ impl ShortLabel for ast::EnumDef {
 
 impl ShortLabel for ast::TraitDef {
     fn short_label(&self) -> Option<String> {
-        short_label_from_node(self, "trait ")
+        if self.unsafe_token().is_some() {
+            short_label_from_node(self, "unsafe trait ")
+        } else {
+            short_label_from_node(self, "trait ")
+        }
     }
 }
 
diff --git a/crates/ra_ide/src/folding_ranges.rs b/crates/ra_ide/src/folding_ranges.rs
index 4379005aa..8657377de 100644
--- a/crates/ra_ide/src/folding_ranges.rs
+++ b/crates/ra_ide/src/folding_ranges.rs
@@ -88,7 +88,7 @@ fn fold_kind(kind: SyntaxKind) -> Option<FoldKind> {
         | ITEM_LIST
         | EXTERN_ITEM_LIST
         | USE_TREE_LIST
-        | BLOCK
+        | BLOCK_EXPR
         | MATCH_ARM_LIST
         | ENUM_VARIANT_LIST
         | TOKEN_TREE => Some(FoldKind::Block),
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index a62f598f0..54d318858 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -869,4 +869,15 @@ fn func(foo: i32) { if true { <|>foo; }; }
             &[r#"pub(crate) async unsafe extern "C" fn foo()"#],
         );
     }
+
+    #[test]
+    fn test_hover_trait_show_qualifiers() {
+        check_hover_result(
+            "
+            //- /lib.rs
+            unsafe trait foo<|>() {}
+            ",
+            &["unsafe trait foo"],
+        );
+    }
 }
diff --git a/crates/ra_ide/src/join_lines.rs b/crates/ra_ide/src/join_lines.rs
index d0def7eaa..63fd6b3e4 100644
--- a/crates/ra_ide/src/join_lines.rs
+++ b/crates/ra_ide/src/join_lines.rs
@@ -129,8 +129,7 @@ fn has_comma_after(node: &SyntaxNode) -> bool {
 }
 
 fn join_single_expr_block(edit: &mut TextEditBuilder, token: &SyntaxToken) -> Option<()> {
-    let block = ast::Block::cast(token.parent())?;
-    let block_expr = ast::BlockExpr::cast(block.syntax().parent()?)?;
+    let block_expr = ast::BlockExpr::cast(token.parent())?;
     if !block_expr.is_standalone() {
         return None;
     }
diff --git a/crates/ra_ide/src/syntax_tree.rs b/crates/ra_ide/src/syntax_tree.rs
index bf97f8c56..86c70ff83 100644
--- a/crates/ra_ide/src/syntax_tree.rs
+++ b/crates/ra_ide/src/syntax_tree.rs
@@ -120,9 +120,8 @@ [email protected]
       [email protected] ")"
     [email protected] " "
     [email protected]
-      [email protected]
-        [email protected] "{"
-        [email protected] "}"
+      [email protected] "{"
+      [email protected] "}"
 "#
             .trim()
         );
@@ -153,26 +152,25 @@ [email protected]
       [email protected] ")"
     [email protected] " "
     [email protected]
-      [email protected]
+      [email protected] "{"