74 files changed, 1597 insertions, 534 deletions
diff --git a/crates/assists/src/handlers/early_return.rs b/crates/assists/src/handlers/early_return.rs
index 7bcc318a9..2c48f32bf 100644
--- a/crates/assists/src/handlers/early_return.rs
+++ b/crates/assists/src/handlers/early_return.rs
@@ -69,7 +69,7 @@ pub(crate) fn convert_to_guarded_return(acc: &mut Assists, ctx: &AssistContext)
    let parent_block = if_expr.syntax().parent()?.ancestors().find_map(ast::BlockExpr::cast)?;
-    if parent_block.expr()? != if_expr.clone().into() {
+    if parent_block.tail_expr()? != if_expr.clone().into() {
        return None;
    }
diff --git a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
index 030b9cd0c..6f35a061c 100644
--- a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -117,10 +117,14 @@ fn existing_definition(db: &RootDatabase, variant_name: &ast::Name, variant: &Va
        .into_iter()
        .filter(|(_, def)| match def {
            // only check type-namespace
-            hir::ScopeDef::ModuleDef(def) => matches!(def,
+            hir::ScopeDef::ModuleDef(def) => matches!(
-                ModuleDef::Module(_) | ModuleDef::Adt(_) |
+                def,
-                ModuleDef::Variant(_) | ModuleDef::Trait(_) |
+                ModuleDef::Module(_)
-                ModuleDef::TypeAlias(_) | ModuleDef::BuiltinType(_)
+                    | ModuleDef::Adt(_)
+                    | ModuleDef::Variant(_)
+                    | ModuleDef::Trait(_)
+                    | ModuleDef::TypeAlias(_)
+                    | ModuleDef::BuiltinType(_)
            ),
            _ => false,
        })
diff --git a/crates/assists/src/handlers/extract_variable.rs b/crates/assists/src/handlers/extract_variable.rs
index 9957012fe..291809205 100644
--- a/crates/assists/src/handlers/extract_variable.rs
+++ b/crates/assists/src/handlers/extract_variable.rs
@@ -139,7 +139,7 @@ impl Anchor {
    fn from(to_extract: &ast::Expr) -> Option<Anchor> {
        to_extract.syntax().ancestors().find_map(|node| {
            if let Some(expr) =
-                node.parent().and_then(ast::BlockExpr::cast).and_then(|it| it.expr())
+                node.parent().and_then(ast::BlockExpr::cast).and_then(|it| it.tail_expr())
            {
                if expr.syntax() == &node {
                    mark::hit!(test_extract_var_last_expr);
diff --git a/crates/assists/src/handlers/infer_function_return_type.rs b/crates/assists/src/handlers/infer_function_return_type.rs
index aa584eb03..f499cdfdc 100644
--- a/crates/assists/src/handlers/infer_function_return_type.rs
+++ b/crates/assists/src/handlers/infer_function_return_type.rs
@@ -89,7 +89,7 @@ fn extract_tail(ctx: &AssistContext) -> Option<(FnType, ast::Expr, InsertOrRepla
            let body = closure.body()?;
            let body_start = body.syntax().first_token()?.text_range().start();
            let (tail_expr, wrap_expr) = match body {
-                ast::Expr::BlockExpr(block) => (block.expr()?, false),
+                ast::Expr::BlockExpr(block) => (block.tail_expr()?, false),
                body => (body, true),
            };
@@ -101,7 +101,7 @@ fn extract_tail(ctx: &AssistContext) -> Option<(FnType, ast::Expr, InsertOrRepla
            let action = ret_ty_to_action(func.ret_type(), rparen_pos)?;
            let body = func.body()?;
-            let tail_expr = body.expr()?;
+            let tail_expr = body.tail_expr()?;
            let ret_range_end = body.l_curly_token()?.text_range().start();
            let ret_range = TextRange::new(rparen_pos, ret_range_end);
diff --git a/crates/assists/src/handlers/inline_function.rs b/crates/assists/src/handlers/inline_function.rs
new file mode 100644
index 000000000..6e351bdcd
--- /dev/null
+++ b/crates/assists/src/handlers/inline_function.rs
@@ -0,0 +1,202 @@
+use ast::make;
+use hir::{HasSource, PathResolution};
+use syntax::{
+    ast::{self, edit::AstNodeEdit, ArgListOwner},
+    AstNode,
+};
+use test_utils::mark;
+use crate::{
+    assist_context::{AssistContext, Assists},
+    AssistId, AssistKind,
+};
+// Assist: inline_function
+//
+// Inlines a function body.
+//
+// ```
+// fn add(a: u32, b: u32) -> u32 { a + b }
+// fn main() {
+//     let x = add<|>(1, 2);
+// }
+// ```
+// ->
+// ```
+// fn add(a: u32, b: u32) -> u32 { a + b }
+// fn main() {
+//     let x = {
+//         let a = 1;
+//         let b = 2;
+//         a + b
+//     };
+// }
+// ```
+pub(crate) fn inline_function(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let path_expr: ast::PathExpr = ctx.find_node_at_offset()?;
+    let call = path_expr.syntax().parent().and_then(ast::CallExpr::cast)?;
+    let path = path_expr.path()?;
+    let function = match ctx.sema.resolve_path(&path)? {
+        PathResolution::Def(hir::ModuleDef::Function(f)) => f,
+        _ => return None,
+    };
+    let function_source = function.source(ctx.db())?;
+    let arguments: Vec<_> = call.arg_list()?.args().collect();
+    let parameters = function_parameter_patterns(&function_source.value)?;
+    if arguments.len() != parameters.len() {
+        // Can't inline the function because they've passed the wrong number of
+        // arguments to this function
+        mark::hit!(inline_function_incorrect_number_of_arguments);
+        return None;
+    }
+    let new_bindings = parameters.into_iter().zip(arguments);
+    let body = function_source.value.body()?;
+    acc.add(
+        AssistId("inline_function", AssistKind::RefactorInline),
+        format!("Inline `{}`", path),
+        call.syntax().text_range(),
+        |builder| {
+            let mut statements: Vec<ast::Stmt> = Vec::new();
+            for (pattern, value) in new_bindings {
+                statements.push(make::let_stmt(pattern, Some(value)).into());
+            }
+            statements.extend(body.statements());
+            let original_indentation = call.indent_level();
+            let replacement = make::block_expr(statements, body.tail_expr())
+                .reset_indent()
+                .indent(original_indentation);
+            builder.replace_ast(ast::Expr::CallExpr(call), ast::Expr::BlockExpr(replacement));
+        },
+    )
+}
+fn function_parameter_patterns(value: &ast::Fn) -> Option<Vec<ast::Pat>> {
+    let mut patterns = Vec::new();
+    for param in value.param_list()?.params() {
+        let pattern = param.pat()?;
+        patterns.push(pattern);
+    }
+    Some(patterns)
+}
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+    use super::*;
+    #[test]
+    fn no_args_or_return_value_gets_inlined_without_block() {
+        check_assist(
+            inline_function,
+            r#"
+fn foo() { println!("Hello, World!"); }
+fn main() {
+    fo<|>o();
+}
+"#,
+            r#"
+fn foo() { println!("Hello, World!"); }
+fn main() {
+    {
+        println!("Hello, World!");
+    };
+}
+"#,
+        );
+    }
+    #[test]
+    fn args_with_side_effects() {
+        check_assist(
+            inline_function,
+            r#"
+fn foo(name: String) { println!("Hello, {}!", name); }
+fn main() {
+    foo<|>(String::from("Michael"));
+}
+"#,
+            r#"
+fn foo(name: String) { println!("Hello, {}!", name); }
+fn main() {
+    {
+        let name = String::from("Michael");
+        println!("Hello, {}!", name);
+    };
+}
+"#,
+        );
+    }
+    #[test]
+    fn method_inlining_isnt_supported() {
+        check_assist_not_applicable(
+            inline_function,
+            r"
+struct Foo;
+impl Foo { fn bar(&self) {} }
+fn main() { Foo.bar<|>(); }
+",
+        );
+    }
+    #[test]
+    fn not_applicable_when_incorrect_number_of_parameters_are_provided() {
+        mark::check!(inline_function_incorrect_number_of_arguments);
+        check_assist_not_applicable(
+            inline_function,
+            r#"
+fn add(a: u32, b: u32) -> u32 { a + b }
+fn main() { let x = add<|>(42); }
+"#,
+        );
+    }
+    #[test]
+    fn function_with_multiple_statements() {
+        check_assist(
+            inline_function,
+            r#"
+fn foo(a: u32, b: u32) -> u32 {
+    let x = a + b;
+    let y = x - b;
+    x * y
+}
+fn main() {
+    let x = foo<|>(1, 2);
+}
+"#,
+            r#"
+fn foo(a: u32, b: u32) -> u32 {
+    let x = a + b;
+    let y = x - b;
+    x * y
+}
+fn main() {
+    let x = {
+        let a = 1;
+        let b = 2;
+        let x = a + b;
+        let y = x - b;
+        x * y
+    };
+}
+"#,
+        );
+    }
+}
diff --git a/crates/assists/src/handlers/move_guard.rs b/crates/assists/src/handlers/move_guard.rs
index eaffd80ce..4318ca6dc 100644
--- a/crates/assists/src/handlers/move_guard.rs
+++ b/crates/assists/src/handlers/move_guard.rs
@@ -98,7 +98,7 @@ pub(crate) fn move_arm_cond_to_match_guard(acc: &mut Assists, ctx: &AssistContex
    let mut replace_node = None;
    let if_expr: IfExpr = IfExpr::cast(arm_body.syntax().clone()).or_else(|| {
        let block_expr = BlockExpr::cast(arm_body.syntax().clone())?;
-        if let Expr::IfExpr(e) = block_expr.expr()? {
+        if let Expr::IfExpr(e) = block_expr.tail_expr()? {
            replace_node = Some(block_expr.syntax().clone());
            Some(e)
        } else {
@@ -128,7 +128,7 @@ pub(crate) fn move_arm_cond_to_match_guard(acc: &mut Assists, ctx: &AssistContex
        |edit| {
            let then_only_expr = then_block.statements().next().is_none();
-            match &then_block.expr() {
+            match &then_block.tail_expr() {
                Some(then_expr) if then_only_expr => {
                    edit.replace(replace_node.text_range(), then_expr.syntax().text())
                }
diff --git a/crates/assists/src/handlers/extract_assignment.rs b/crates/assists/src/handlers/pull_assignment_up.rs
index 281cf5d24..63b662fad 100644
--- a/crates/assists/src/handlers/extract_assignment.rs
+++ b/crates/assists/src/handlers/pull_assignment_up.rs
@@ -1,4 +1,3 @@
-use hir::AsName;
 use syntax::{
    ast::{self, edit::AstNodeEdit, make},
    AstNode,
@@ -10,9 +9,9 @@ use crate::{
    AssistId, AssistKind,
 };
-// Assist: extract_assignment
+// Assist: pull_assignment_up
 //
-// Extracts variable assigment to outside an if or match statement.
+// Extracts variable assignment to outside an if or match statement.
 //
 // ```
 // fn main() {
@@ -37,16 +36,24 @@ use crate::{
 //     };
 // }
 // ```
-pub(crate) fn extract_assigment(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+pub(crate) fn pull_assignment_up(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let name = ctx.find_node_at_offset::<ast::NameRef>()?.as_name();
+    let assign_expr = ctx.find_node_at_offset::<ast::BinExpr>()?;
+    let name_expr = if assign_expr.op_kind()? == ast::BinOp::Assignment {
+        assign_expr.lhs()?
+    } else {
+        return None;
+    };
    let (old_stmt, new_stmt) = if let Some(if_expr) = ctx.find_node_at_offset::<ast::IfExpr>() {
        (
            ast::Expr::cast(if_expr.syntax().to_owned())?,
-            exprify_if(&if_expr, &name)?.indent(if_expr.indent_level()),
+            exprify_if(&if_expr, &ctx.sema, &name_expr)?.indent(if_expr.indent_level()),
        )
    } else if let Some(match_expr) = ctx.find_node_at_offset::<ast::MatchExpr>() {
-        (ast::Expr::cast(match_expr.syntax().to_owned())?, exprify_match(&match_expr, &name)?)
+        (
+            ast::Expr::cast(match_expr.syntax().to_owned())?,
+            exprify_match(&match_expr, &ctx.sema, &name_expr)?,
+        )
    } else {
        return None;
    };
@@ -54,22 +61,26 @@ pub(crate) fn extract_assigment(acc: &mut Assists, ctx: &AssistContext) -> Optio
    let expr_stmt = make::expr_stmt(new_stmt);
    acc.add(
-        AssistId("extract_assignment", AssistKind::RefactorExtract),
+        AssistId("pull_assignment_up", AssistKind::RefactorExtract),
-        "Extract assignment",
+        "Pull assignment up",
        old_stmt.syntax().text_range(),
        move |edit| {
-            edit.replace(old_stmt.syntax().text_range(), format!("{} = {};", name, expr_stmt));
+            edit.replace(old_stmt.syntax().text_range(), format!("{} = {};", name_expr, expr_stmt));
        },
    )
 }
-fn exprify_match(match_expr: &ast::MatchExpr, name: &hir::Name) -> Option<ast::Expr> {
+fn exprify_match(
+    match_expr: &ast::MatchExpr,
+    sema: &hir::Semantics<ide_db::RootDatabase>,
+    name: &ast::Expr,
+) -> Option<ast::Expr> {
    let new_arm_list = match_expr
        .match_arm_list()?
        .arms()
        .map(|arm| {
            if let ast::Expr::BlockExpr(block) = arm.expr()? {
-                let new_block = exprify_block(&block, name)?.indent(block.indent_level());
+                let new_block = exprify_block(&block, sema, name)?.indent(block.indent_level());
                Some(arm.replace_descendant(block, new_block))
            } else {
                None
@@ -82,22 +93,32 @@ fn exprify_match(match_expr: &ast::MatchExpr, name: &hir::Name) -> Option<ast::E
    Some(make::expr_match(match_expr.expr()?, new_arm_list))
 }
-fn exprify_if(statement: &ast::IfExpr, name: &hir::Name) -> Option<ast::Expr> {
+fn exprify_if(
-    let then_branch = exprify_block(&statement.then_branch()?, name)?;
+    statement: &ast::IfExpr,
+    sema: &hir::Semantics<ide_db::RootDatabase>,
+    name: &ast::Expr,
+) -> Option<ast::Expr> {
+    let then_branch = exprify_block(&statement.then_branch()?, sema, name)?;
    let else_branch = match statement.else_branch()? {
-        ast::ElseBranch::Block(ref block) => ast::ElseBranch::Block(exprify_block(block, name)?),
+        ast::ElseBranch::Block(ref block) => {
+            ast::ElseBranch::Block(exprify_block(block, sema, name)?)
+        }
        ast::ElseBranch::IfExpr(expr) => {
-            mark::hit!(test_extract_assigment_chained_if);
+            mark::hit!(test_pull_assignment_up_chained_if);
            ast::ElseBranch::IfExpr(ast::IfExpr::cast(
-                exprify_if(&expr, name)?.syntax().to_owned(),
+                exprify_if(&expr, sema, name)?.syntax().to_owned(),
            )?)
        }
    };
    Some(make::expr_if(statement.condition()?, then_branch, Some(else_branch)))
 }
-fn exprify_block(block: &ast::BlockExpr, name: &hir::Name) -> Option<ast::BlockExpr> {
+fn exprify_block(
-    if block.expr().is_some() {
+    block: &ast::BlockExpr,
+    sema: &hir::Semantics<ide_db::RootDatabase>,
+    name: &ast::Expr,
+) -> Option<ast::BlockExpr> {
+    if block.tail_expr().is_some() {
        return None;
    }
@@ -106,8 +127,7 @@ fn exprify_block(block: &ast::BlockExpr, name: &hir::Name) -> Option<ast::BlockE
    if let ast::Stmt::ExprStmt(stmt) = stmt {
        if let ast::Expr::BinExpr(expr) = stmt.expr()? {
-            if expr.op_kind()? == ast::BinOp::Assignment
+            if expr.op_kind()? == ast::BinOp::Assignment && is_equivalent(sema, &expr.lhs()?, name)
-                && &expr.lhs()?.name_ref()?.as_name() == name
            {
                // The last statement in the block is an assignment to the name we want
                return Some(make::block_expr(stmts, Some(expr.rhs()?)));
@@ -117,6 +137,29 @@ fn exprify_block(block: &ast::BlockExpr, name: &hir::Name) -> Option<ast::BlockE
    None
 }
+fn is_equivalent(
+    sema: &hir::Semantics<ide_db::RootDatabase>,
+    expr0: &ast::Expr,
+    expr1: &ast::Expr,
+) -> bool {
+    match (expr0, expr1) {
+        (ast::Expr::FieldExpr(field_expr0), ast::Expr::FieldExpr(field_expr1)) => {
+            mark::hit!(test_pull_assignment_up_field_assignment);
+            sema.resolve_field(field_expr0) == sema.resolve_field(field_expr1)
+        }
+        (ast::Expr::PathExpr(path0), ast::Expr::PathExpr(path1)) => {
+            let path0 = path0.path();
+            let path1 = path1.path();
+            if let (Some(path0), Some(path1)) = (path0, path1) {
+                sema.resolve_path(&path0) == sema.resolve_path(&path1)
+            } else {
+                false
+            }
+        }
+        _ => false,
+    }
+}
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -124,9 +167,9 @@ mod tests {
    use crate::tests::{check_assist, check_assist_not_applicable};
    #[test]
-    fn test_extract_assignment_if() {
+    fn test_pull_assignment_up_if() {
        check_assist(
-            extract_assigment,
+            pull_assignment_up,
            r#"
 fn foo() {
    let mut a = 1;
@@ -151,9 +194,9 @@ fn foo() {
    }
    #[test]
-    fn test_extract_assignment_match() {
+    fn test_pull_assignment_up_match() {
        check_assist(
-            extract_assigment,
+            pull_assignment_up,
            r#"
 fn foo() {
    let mut a = 1;
@@ -190,9 +233,9 @@ fn foo() {
    }
    #[test]
-    fn test_extract_assignment_not_last_not_applicable() {
+    fn test_pull_assignment_up_not_last_not_applicable() {
        check_assist_not_applicable(
-            extract_assigment,
+            pull_assignment_up,
            r#"
 fn foo() {
    let mut a = 1;
@@ -208,10 +251,10 @@ fn foo() {
    }
    #[test]
-    fn test_extract_assignment_chained_if() {
+    fn test_pull_assignment_up_chained_if() {
-        mark::check!(test_extract_assigment_chained_if);
+        mark::check!(test_pull_assignment_up_chained_if);
        check_assist(
-            extract_assigment,
+            pull_assignment_up,
            r#"
 fn foo() {
    let mut a = 1;
@@ -240,9 +283,9 @@ fn foo() {
    }
    #[test]
-    fn test_extract_assigment_retains_stmts() {
+    fn test_pull_assignment_up_retains_stmts() {
        check_assist(
-            extract_assigment,
+            pull_assignment_up,
            r#"
 fn foo() {
    let mut a = 1;
@@ -271,9 +314,9 @@ fn foo() {
    }
    #[test]
-    fn extract_assignment_let_stmt_not_applicable() {
+    fn pull_assignment_up_let_stmt_not_applicable() {
        check_assist_not_applicable(
-            extract_assigment,
+            pull_assignment_up,
            r#"
 fn foo() {
    let mut a = 1;
@@ -288,9 +331,9 @@ fn foo() {
    }
    #[test]
-    fn extract_assignment_if_missing_assigment_not_applicable() {
+    fn pull_assignment_up_if_missing_assigment_not_applicable() {
        check_assist_not_applicable(
-            extract_assigment,
+            pull_assignment_up,
            r#"
 fn foo() {
    let mut a = 1;
@@ -303,9 +346,9 @@ fn foo() {
    }
    #[test]
-    fn extract_assignment_match_missing_assigment_not_applicable() {
+    fn pull_assignment_up_match_missing_assigment_not_applicable() {
        check_assist_not_applicable(
-            extract_assigment,
+            pull_assignment_up,
            r#"
 fn foo() {
    let mut a = 1;
@@ -322,4 +365,36 @@ fn foo() {
 }"#,
        )
    }
+    #[test]
+    fn test_pull_assignment_up_field_assignment() {
+        mark::check!(test_pull_assignment_up_field_assignment);
+        check_assist(
+            pull_assignment_up,
+            r#"
+struct A(usize);
+fn foo() {
+    let mut a = A(1);
+    if true {
+        <|>a.0 = 2;
+    } else {
+        a.0 = 3;
+    }
+}"#,
+            r#"
+struct A(usize);
+fn foo() {
+    let mut a = A(1);
+    a.0 = if true {
+        2
+    } else {
+        3
+    };
+}"#,
+        )
+    }
 }
diff --git a/crates/assists/src/handlers/replace_if_let_with_match.rs b/crates/assists/src/handlers/replace_if_let_with_match.rs
index 4a355c66f..b67219222 100644
--- a/crates/assists/src/handlers/replace_if_let_with_match.rs
+++ b/crates/assists/src/handlers/replace_if_let_with_match.rs
@@ -138,7 +138,7 @@ pub(crate) fn replace_match_with_if_let(acc: &mut Assists, ctx: &AssistContext)
            };
            let else_expr = match else_expr {
                ast::Expr::BlockExpr(block)
-                    if block.statements().count() == 0 && block.expr().is_none() =>
+                    if block.statements().count() == 0 && block.tail_expr().is_none() =>
                {
                    None
                }
diff --git a/crates/assists/src/handlers/wrap_return_type_in_result.rs b/crates/assists/src/handlers/wrap_return_type_in_result.rs
index 59e5debb1..358b61046 100644
--- a/crates/assists/src/handlers/wrap_return_type_in_result.rs
+++ b/crates/assists/src/handlers/wrap_return_type_in_result.rs
@@ -98,7 +98,7 @@ impl TailReturnCollector {
        }
        // Browse tail expressions for each block
-        if let Some(expr) = block_expr.expr() {
+        if let Some(expr) = block_expr.tail_expr() {
            if let Some(last_exprs) = get_tail_expr_from_block(&expr) {
                for last_expr in last_exprs {
                    let last_expr = match last_expr {
@@ -170,7 +170,7 @@ impl TailReturnCollector {
    }
    fn collect_tail_exprs(&mut self, block: &BlockExpr) {
-        if let Some(expr) = block.expr() {
+        if let Some(expr) = block.tail_expr() {
            self.handle_exprs(&expr, true);
            self.fetch_tail_exprs(&expr);
        }
@@ -206,7 +206,7 @@ fn get_tail_expr_from_block(expr: &Expr) -> Option<Vec<NodeType>> {
        Expr::IfExpr(if_expr) => {
            let mut nodes = vec![];
            for block in if_expr.blocks() {
-                if let Some(block_expr) = block.expr() {
+                if let Some(block_expr) = block.tail_expr() {
                    if let Some(tail_exprs) = get_tail_expr_from_block(&block_expr) {
                        nodes.extend(tail_exprs);
                    }
@@ -228,7 +228,7 @@ fn get_tail_expr_from_block(expr: &Expr) -> Option<Vec<NodeType>> {
            while_expr.syntax().last_child().map(|lc| vec![NodeType::Node(lc)])
        }
        Expr::BlockExpr(block_expr) => {
-            block_expr.expr().map(|lc| vec![NodeType::Node(lc.syntax().clone())])
+            block_expr.tail_expr().map(|lc| vec![NodeType::Node(lc.syntax().clone())])
        }
        Expr::MatchExpr(match_expr) => {
            let arm_list = match_expr.match_arm_list()?;
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs
index 212464f85..9c2a95735 100644
--- a/crates/assists/src/lib.rs
+++ b/crates/assists/src/lib.rs
@@ -116,7 +116,6 @@ mod handlers {
    mod convert_integer_literal;
    mod early_return;
    mod expand_glob_import;
-    mod extract_assignment;
    mod extract_module_to_file;
    mod extract_struct_from_enum_variant;
    mod extract_variable;
@@ -125,13 +124,14 @@ mod handlers {
    mod flip_binexpr;
    mod flip_comma;
    mod flip_trait_bound;
-    mod generate_derive;
    mod generate_default_from_enum_variant;
+    mod generate_derive;
    mod generate_from_impl_for_enum;
    mod generate_function;
    mod generate_impl;
    mod generate_new;
    mod infer_function_return_type;
+    mod inline_function;
    mod inline_local_variable;
    mod introduce_named_lifetime;
    mod invert_if;
@@ -139,6 +139,7 @@ mod handlers {
    mod merge_match_arms;
    mod move_bounds;
    mod move_guard;
+    mod pull_assignment_up;
    mod qualify_path;
    mod raw_string;
    mod remove_dbg;
@@ -168,7 +169,6 @@ mod handlers {
            convert_integer_literal::convert_integer_literal,
            early_return::convert_to_guarded_return,
            expand_glob_import::expand_glob_import,
-            extract_assignment::extract_assigment,
            extract_module_to_file::extract_module_to_file,
            extract_struct_from_enum_variant::extract_struct_from_enum_variant,
            extract_variable::extract_variable,
@@ -177,13 +177,14 @@ mod handlers {
            flip_binexpr::flip_binexpr,
            flip_comma::flip_comma,
            flip_trait_bound::flip_trait_bound,
-            generate_derive::generate_derive,
            generate_default_from_enum_variant::generate_default_from_enum_variant,
+            generate_derive::generate_derive,
            generate_from_impl_for_enum::generate_from_impl_for_enum,
            generate_function::generate_function,
            generate_impl::generate_impl,
            generate_new::generate_new,
            infer_function_return_type::infer_function_return_type,
+            inline_function::inline_function,
            inline_local_variable::inline_local_variable,
            introduce_named_lifetime::introduce_named_lifetime,
            invert_if::invert_if,
@@ -192,6 +193,7 @@ mod handlers {
            move_bounds::move_bounds_to_where_clause,
            move_guard::move_arm_cond_to_match_guard,
            move_guard::move_guard_to_arm_body,
+            pull_assignment_up::pull_assignment_up,
            qualify_path::qualify_path,
            raw_string::add_hash,
            raw_string::make_usual_string,
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index b91a816e8..b15352cf3 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -238,35 +238,6 @@ fn qux(bar: Bar, baz: Baz) {}
 }
 #[test]
-fn doctest_extract_assignment() {
-    check_doc_test(
-        "extract_assignment",
-        r#####"
-fn main() {
-    let mut foo = 6;
-    if true {
-        <|>foo = 5;
-    } else {
-        foo = 4;
-    }
-}
-"#####,
-        r#####"
-fn main() {
-    let mut foo = 6;
-    foo = if true {
-        5
-    } else {
-        4
-    };
-}
-"#####,
-    )
-}
-#[test]
 fn doctest_extract_module_to_file() {
    check_doc_test(
        "extract_module_to_file",
@@ -560,6 +531,29 @@ fn foo() -> i32 { 42i32 }
 }
 #[test]
+fn doctest_inline_function() {
+    check_doc_test(
+        "inline_function",
+        r#####"
+fn add(a: u32, b: u32) -> u32 { a + b }
+fn main() {
+    let x = add<|>(1, 2);
+}
+"#####,
+        r#####"
+fn add(a: u32, b: u32) -> u32 { a + b }
+fn main() {
+    let x = {
+        let a = 1;
+        let b = 2;
+        a + b
+    };
+}
+"#####,
+    )
+}
+#[test]
 fn doctest_inline_local_variable() {
    check_doc_test(
        "inline_local_variable",
@@ -767,6 +761,35 @@ fn handle(action: Action) {
 }
 #[test]
+fn doctest_pull_assignment_up() {
+    check_doc_test(
+        "pull_assignment_up",
+        r#####"
+fn main() {
+    let mut foo = 6;
+    if true {
+        <|>foo = 5;
+    } else {
+        foo = 4;
+    }
+}
+"#####,
+        r#####"
+fn main() {
+    let mut foo = 6;
+    foo = if true {
+        5
+    } else {
+        4
+    };
+}
+"#####,
+    )
+}
+#[test]
 fn doctest_qualify_path() {
    check_doc_test(
        "qualify_path",
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index b05596446..8212cd129 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -37,7 +37,7 @@ pub fn extract_trivial_expression(block: &ast::BlockExpr) -> Option<ast::Expr> {
        non_trivial_children.next().is_some()
    };
-    if let Some(expr) = block.expr() {
+    if let Some(expr) = block.tail_expr() {
        if has_anything_else(expr.syntax()) {
            return None;
        }
diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs
index 81a6d00e2..2f41a3f96 100644
--- a/crates/completion/src/completions/unqualified_path.rs
+++ b/crates/completion/src/completions/unqualified_path.rs
@@ -124,8 +124,8 @@ fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &T
 // Note that having this flag set to `true` does not guarantee that the feature is enabled: your client needs to have the corredponding
 // capability enabled.
 fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
-    let _p = profile::span("fuzzy_completion");
    let potential_import_name = ctx.token.to_string();
+    let _p = profile::span("fuzzy_completion").detail(|| potential_import_name.clone());
    if potential_import_name.len() < 2 {
        return None;
@@ -142,6 +142,7 @@ fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<()
        Some(40),
        potential_import_name,
        true,
+        true,
    )
    .filter_map(|import_candidate| {
        Some(match import_candidate {
diff --git a/crates/completion/src/context.rs b/crates/completion/src/context.rs
index 41de324d8..f979697ab 100644
--- a/crates/completion/src/context.rs
+++ b/crates/completion/src/context.rs
@@ -458,7 +458,7 @@ impl<'a> CompletionContext<'a> {
                    }
                    if let Some(block) = ast::BlockExpr::cast(node) {
                        return Some(
-                            block.expr().map(|e| e.syntax().text_range())
+                            block.tail_expr().map(|e| e.syntax().text_range())
                                == Some(name_ref.syntax().text_range()),
                        );
                    }
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 62eccf475..cc1938333 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -5,9 +5,7 @@ use arrayvec::ArrayVec;
 use base_db::{CrateDisplayName, CrateId, Edition, FileId};
 use either::Either;
 use hir_def::{
-    adt::ReprKind,
+    adt::{ReprKind, StructKind, VariantData},
-    adt::StructKind,
-    adt::VariantData,
    builtin_type::BuiltinType,
    expr::{BindingAnnotation, LabelId, Pat, PatId},
    import_map,
@@ -31,7 +29,7 @@ use hir_expand::{
 };
 use hir_ty::{
    autoderef,
-    display::{HirDisplayError, HirFormatter},
+    display::{write_bounds_like_dyn_trait, HirDisplayError, HirFormatter},
    method_resolution,
    traits::{FnTrait, Solution, SolutionVariables},
    ApplicationTy, BoundVar, CallableDefId, Canonical, DebruijnIndex, FnSig, GenericPredicate,
@@ -745,6 +743,18 @@ impl Function {
        db.function_data(self.id).name.clone()
    }
+    /// Get this function's return type
+    pub fn ret_type(self, db: &dyn HirDatabase) -> Type {
+        let resolver = self.id.resolver(db.upcast());
+        let ret_type = &db.function_data(self.id).ret_type;
+        let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
+        let environment = TraitEnvironment::lower(db, &resolver);
+        Type {
+            krate: self.id.lookup(db.upcast()).container.module(db.upcast()).krate,
+            ty: InEnvironment { value: Ty::from_hir_ext(&ctx, ret_type).0, environment },
+        }
+    }
    pub fn self_param(self, db: &dyn HirDatabase) -> Option<SelfParam> {
        if !db.function_data(self.id).has_self_param {
            return None;
@@ -1278,6 +1288,18 @@ impl TypeParam {
        }
    }
+    pub fn trait_bounds(self, db: &dyn HirDatabase) -> Vec<Trait> {
+        db.generic_predicates_for_param(self.id)
+            .into_iter()
+            .filter_map(|pred| match &pred.value {
+                hir_ty::GenericPredicate::Implemented(trait_ref) => {
+                    Some(Trait::from(trait_ref.trait_))
+                }
+                _ => None,
+            })
+            .collect()
+    }
    pub fn default(self, db: &dyn HirDatabase) -> Option<Type> {
        let params = db.generic_defaults(self.id.parent);
        let local_idx = hir_ty::param_idx(db, self.id)?;
@@ -1293,6 +1315,20 @@ impl TypeParam {
    }
 }
+impl HirDisplay for TypeParam {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write!(f, "{}", self.name(f.db))?;
+        let bounds = f.db.generic_predicates_for_param(self.id);
+        let substs = Substs::type_params(f.db, self.id.parent);
+        let predicates = bounds.iter().cloned().map(|b| b.subst(&substs)).collect::<Vec<_>>();
+        if !(predicates.is_empty() || f.omit_verbose_types()) {
+            write!(f, ": ")?;
+            write_bounds_like_dyn_trait(&predicates, f)?;
+        }
+        Ok(())
+    }
+}
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct LifetimeParam {
    pub(crate) id: LifetimeParamId,
@@ -1331,6 +1367,12 @@ impl ConstParam {
    pub fn parent(self, _db: &dyn HirDatabase) -> GenericDef {
        self.id.parent.into()
    }
+    pub fn ty(self, db: &dyn HirDatabase) -> Type {
+        let def = self.id.parent;
+        let krate = def.module(db.upcast()).krate;
+        Type::new(db, krate, def, db.const_param_ty(self.id))
+    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -1600,9 +1642,10 @@ impl Type {
    }
    pub fn is_fn(&self) -> bool {
-        matches!(&self.ty.value,
+        matches!(
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::FnDef(..), .. }) |
+            &self.ty.value,
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::FnPtr { .. }, .. })
+            Ty::Apply(ApplicationTy { ctor: TypeCtor::FnDef(..), .. })
+                | Ty::Apply(ApplicationTy { ctor: TypeCtor::FnPtr { .. }, .. })
        )
    }
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index 6b79e7bad..9e6426b31 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -2,6 +2,7 @@
 use std::{ops, sync::Arc};
+use arena::map::ArenaMap;
 use base_db::CrateId;
 use cfg::{CfgExpr, CfgOptions};
 use either::Either;
@@ -21,7 +22,8 @@ use crate::{
    nameres::ModuleSource,
    path::{ModPath, PathKind},
    src::HasChildSource,
-    AdtId, AttrDefId, GenericParamId, Lookup,
+    AdtId, AttrDefId, EnumId, GenericParamId, HasModule, LocalEnumVariantId, LocalFieldId, Lookup,
+    VariantId,
 };
 /// Holds documentation
@@ -210,16 +212,10 @@ impl Attrs {
                }
            }
            AttrDefId::FieldId(it) => {
-                let src = it.parent.child_source(db);
+                return db.fields_attrs(it.parent)[it.local_id].clone();
-                match &src.value[it.local_id] {
-                    Either::Left(_tuple) => RawAttrs::default(),
-                    Either::Right(record) => RawAttrs::from_attrs_owner(db, src.with_value(record)),
-                }
            }
-            AttrDefId::EnumVariantId(var_id) => {
+            AttrDefId::EnumVariantId(it) => {
-                let src = var_id.parent.child_source(db);
+                return db.variants_attrs(it.parent)[it.local_id].clone();
-                let src = src.as_ref().map(|it| &it[var_id.local_id]);
-                RawAttrs::from_attrs_owner(db, src.map(|it| it as &dyn AttrsOwner))
            }
            AttrDefId::AdtId(it) => match it {
                AdtId::StructId(it) => attrs_from_item_tree(it.lookup(db).id, db),
@@ -259,6 +255,46 @@ impl Attrs {
        raw_attrs.filter(db, def.krate(db))
    }
+    pub(crate) fn variants_attrs_query(
+        db: &dyn DefDatabase,
+        e: EnumId,
+    ) -> Arc<ArenaMap<LocalEnumVariantId, Attrs>> {
+        let krate = e.lookup(db).container.module(db).krate;
+        let src = e.child_source(db);
+        let mut res = ArenaMap::default();
+        for (id, var) in src.value.iter() {
+            let attrs = RawAttrs::from_attrs_owner(db, src.with_value(var as &dyn AttrsOwner))
+                .filter(db, krate);
+            res.insert(id, attrs)
+        }
+        Arc::new(res)
+    }
+    pub(crate) fn fields_attrs_query(
+        db: &dyn DefDatabase,
+        v: VariantId,
+    ) -> Arc<ArenaMap<LocalFieldId, Attrs>> {
+        let krate = v.module(db).krate;
+        let src = v.child_source(db);
+        let mut res = ArenaMap::default();
+        for (id, fld) in src.value.iter() {
+            let attrs = match fld {
+                Either::Left(_tuple) => Attrs::default(),
+                Either::Right(record) => {
+                    RawAttrs::from_attrs_owner(db, src.with_value(record)).filter(db, krate)
+                }
+            };
+            res.insert(id, attrs);
+        }
+        Arc::new(res)
+    }
    pub fn by_key(&self, key: &'static str) -> AttrQuery<'_> {
        AttrQuery { attrs: self, key }
    }
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 17c72779b..6be1eaade 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -695,7 +695,7 @@ impl ExprCollector<'_> {
        self.collect_stmts_items(block.statements());
        let statements =
            block.statements().filter_map(|s| self.collect_stmt(s)).flatten().collect();
-        let tail = block.expr().map(|e| self.collect_expr(e));
+        let tail = block.tail_expr().map(|e| self.collect_expr(e));
        self.alloc_expr(Expr::Block { statements, tail, label: None }, syntax_node_ptr)
    }
diff --git a/crates/hir_def/src/db.rs b/crates/hir_def/src/db.rs
index d1a459066..d3bf5b34c 100644
--- a/crates/hir_def/src/db.rs
+++ b/crates/hir_def/src/db.rs
@@ -1,6 +1,7 @@
 //! Defines database & queries for name resolution.
 use std::sync::Arc;
+use arena::map::ArenaMap;
 use base_db::{salsa, CrateId, SourceDatabase, Upcast};
 use hir_expand::{db::AstDatabase, HirFileId};
 use syntax::SmolStr;
@@ -16,8 +17,8 @@ use crate::{
    lang_item::{LangItemTarget, LangItems},
    nameres::CrateDefMap,
    AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, FunctionId, FunctionLoc,
-    GenericDefId, ImplId, ImplLoc, StaticId, StaticLoc, StructId, StructLoc, TraitId, TraitLoc,
+    GenericDefId, ImplId, ImplLoc, LocalEnumVariantId, LocalFieldId, StaticId, StaticLoc, StructId,
-    TypeAliasId, TypeAliasLoc, UnionId, UnionLoc,
+    StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc, VariantId,
 };
 #[salsa::query_group(InternDatabaseStorage)]
@@ -92,6 +93,12 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
    #[salsa::invoke(GenericParams::generic_params_query)]
    fn generic_params(&self, def: GenericDefId) -> Arc<GenericParams>;
+    #[salsa::invoke(Attrs::variants_attrs_query)]
+    fn variants_attrs(&self, def: EnumId) -> Arc<ArenaMap<LocalEnumVariantId, Attrs>>;
+    #[salsa::invoke(Attrs::fields_attrs_query)]
+    fn fields_attrs(&self, def: VariantId) -> Arc<ArenaMap<LocalFieldId, Attrs>>;
    #[salsa::invoke(Attrs::attrs_query)]
    fn attrs(&self, def: AttrDefId) -> Attrs;
diff --git a/crates/hir_def/src/diagnostics.rs b/crates/hir_def/src/diagnostics.rs
index c71266dc0..ab3f059ce 100644
--- a/crates/hir_def/src/diagnostics.rs
+++ b/crates/hir_def/src/diagnostics.rs
@@ -133,6 +133,10 @@ impl Diagnostic for InactiveCode {
 // This diagnostic is shown when a procedural macro can not be found. This usually means that
 // procedural macro support is simply disabled (and hence is only a weak hint instead of an error),
 // but can also indicate project setup problems.
+//
+// If you are seeing a lot of "proc macro not expanded" warnings, you can add this option to the
+// `rust-analyzer.diagnostics.disabled` list to prevent them from showing. Alternatively you can
+// enable support for procedural macros (see `rust-analyzer.procMacro.enable`).
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct UnresolvedProcMacro {
    pub file: HirFileId,
diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs
index 30b22f51d..e5368b293 100644
--- a/crates/hir_def/src/import_map.rs
+++ b/crates/hir_def/src/import_map.rs
@@ -7,9 +7,8 @@ use fst::{self, Streamer};
 use hir_expand::name::Name;
 use indexmap::{map::Entry, IndexMap};
 use itertools::Itertools;
-use rustc_hash::{FxHashMap, FxHashSet, FxHasher};
+use rustc_hash::{FxHashSet, FxHasher};
-use smallvec::SmallVec;
+use test_utils::mark;
-use syntax::SmolStr;
 use crate::{
    db::DefDatabase, item_scope::ItemInNs, visibility::Visibility, AssocItemId, ModuleDefId,
@@ -25,6 +24,8 @@ pub struct ImportInfo {
    pub path: ImportPath,
    /// The module containing this item.
    pub container: ModuleId,
+    /// Whether the import is a trait associated item or not.
+    pub is_trait_assoc_item: bool,
 }
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -64,10 +65,6 @@ pub struct ImportMap {
    /// the index of the first one.
    importables: Vec<ItemInNs>,
    fst: fst::Map<Vec<u8>>,
-    /// Maps names of associated items to the item's ID. Only includes items whose defining trait is
-    /// exported.
-    assoc_map: FxHashMap<SmolStr, SmallVec<[AssocItemId; 1]>>,
 }
 impl ImportMap {
@@ -108,14 +105,27 @@ impl ImportMap {
                for item in per_ns.iter_items() {
                    let path = mk_path();
+                    let path_len = path.len();
+                    let import_info =
+                        ImportInfo { path, container: module, is_trait_assoc_item: false };
+                    if let Some(ModuleDefId::TraitId(tr)) = item.as_module_def_id() {
+                        import_map.collect_trait_assoc_items(
+                            db,
+                            tr,
+                            matches!(item, ItemInNs::Types(_)),
+                            &import_info,
+                        );
+                    }
                    match import_map.map.entry(item) {
                        Entry::Vacant(entry) => {
-                            entry.insert(ImportInfo { path, container: module });
+                            entry.insert(import_info);
                        }
                        Entry::Occupied(mut entry) => {
                            // If the new path is shorter, prefer that one.
-                            if path.len() < entry.get().path.len() {
+                            if path_len < entry.get().path.len() {
-                                *entry.get_mut() = ImportInfo { path, container: module };
+                                *entry.get_mut() = import_info;
                            } else {
                                continue;
                            }
@@ -128,11 +138,6 @@ impl ImportMap {
                    if let Some(ModuleDefId::ModuleId(mod_id)) = item.as_module_def_id() {
                        worklist.push((mod_id, mk_path()));
                    }
-                    // If we've added a path to a trait, add the trait's methods to the method map.
-                    if let Some(ModuleDefId::TraitId(tr)) = item.as_module_def_id() {
-                        import_map.collect_trait_methods(db, tr);
-                    }
                }
            }
        }
@@ -153,12 +158,10 @@ impl ImportMap {
                }
            }
-            let start = last_batch_start;
+            let key = fst_path(&importables[last_batch_start].1.path);
-            last_batch_start = idx + 1;
+            builder.insert(key, last_batch_start as u64).unwrap();
-            let key = fst_path(&importables[start].1.path);
-            builder.insert(key, start as u64).unwrap();
+            last_batch_start = idx + 1;
        }
        import_map.fst = fst::Map::new(builder.into_inner().unwrap()).unwrap();
@@ -176,10 +179,34 @@ impl ImportMap {
        self.map.get(&item)
    }
-    fn collect_trait_methods(&mut self, db: &dyn DefDatabase, tr: TraitId) {
+    fn collect_trait_assoc_items(
-        let data = db.trait_data(tr);
+        &mut self,
-        for (name, item) in data.items.iter() {
+        db: &dyn DefDatabase,
-            self.assoc_map.entry(name.to_string().into()).or_default().push(*item);
+        tr: TraitId,
+        is_type_in_ns: bool,
+        original_import_info: &ImportInfo,
+    ) {
+        for (assoc_item_name, item) in &db.trait_data(tr).items {
+            let module_def_id = match item {
+                AssocItemId::FunctionId(f) => ModuleDefId::from(*f),
+                AssocItemId::ConstId(c) => ModuleDefId::from(*c),
+                // cannot use associated type aliases directly: need a `<Struct as Trait>::TypeAlias`
+                // qualifier, ergo no need to store it for imports in import_map
+                AssocItemId::TypeAliasId(_) => {
+                    mark::hit!(type_aliases_ignored);
+                    continue;
+                }
+            };
+            let assoc_item = if is_type_in_ns {
+                ItemInNs::Types(module_def_id)
+            } else {
+                ItemInNs::Values(module_def_id)
+            };
+            let mut assoc_item_info = original_import_info.clone();
+            assoc_item_info.path.segments.push(assoc_item_name.to_owned());
+            assoc_item_info.is_trait_assoc_item = true;
+            self.map.insert(assoc_item, assoc_item_info);
        }
    }
 }
@@ -302,38 +329,38 @@ impl Query {
        self.exclude_import_kinds.insert(import_kind);
        self
    }
-}
-fn contains_query(query: &Query, input_path: &ImportPath, enforce_lowercase: bool) -> bool {
+    fn import_matches(&self, import: &ImportInfo, enforce_lowercase: bool) -> bool {
-    let mut input = if query.name_only {
+        let mut input = if import.is_trait_assoc_item || self.name_only {
-        input_path.segments.last().unwrap().to_string()
+            import.path.segments.last().unwrap().to_string()
-    } else {
+        } else {
-        input_path.to_string()
+            import.path.to_string()
-    };
+        };
-    if enforce_lowercase || !query.case_sensitive {
+        if enforce_lowercase || !self.case_sensitive {
-        input.make_ascii_lowercase();
+            input.make_ascii_lowercase();
-    }
+        }
-    let query_string =
+        let query_string =
-        if !enforce_lowercase && query.case_sensitive { &query.query } else { &query.lowercased };
+            if !enforce_lowercase && self.case_sensitive { &self.query } else { &self.lowercased };
-    match query.search_mode {
+        match self.search_mode {
-        SearchMode::Equals => &input == query_string,
+            SearchMode::Equals => &input == query_string,
-        SearchMode::Contains => input.contains(query_string),
+            SearchMode::Contains => input.contains(query_string),
-        SearchMode::Fuzzy => {
+            SearchMode::Fuzzy => {
-            let mut unchecked_query_chars = query_string.chars();
+                let mut unchecked_query_chars = query_string.chars();
-            let mut mismatching_query_char = unchecked_query_chars.next();
+                let mut mismatching_query_char = unchecked_query_chars.next();
-            for input_char in input.chars() {
+                for input_char in input.chars() {
-                match mismatching_query_char {
+                    match mismatching_query_char {
-                    None => return true,
+                        None => return true,
-                    Some(matching_query_char) if matching_query_char == input_char => {
+                        Some(matching_query_char) if matching_query_char == input_char => {
-                        mismatching_query_char = unchecked_query_chars.next();
+                            mismatching_query_char = unchecked_query_chars.next();
+                        }
+                        _ => (),
                    }
-                    _ => (),
                }
+                mismatching_query_char.is_none()
            }
-            mismatching_query_char.is_none()
        }
    }
 }
@@ -366,13 +393,13 @@ pub fn search_dependencies<'a>(
            let import_map = &import_maps[indexed_value.index];
            let importables = &import_map.importables[indexed_value.value as usize..];
-            // Path shared by the importable items in this group.
+            let common_importable_data = &import_map.map[&importables[0]];
-            let common_importables_path = &import_map.map[&importables[0]].path;
+            if !query.import_matches(common_importable_data, true) {
-            if !contains_query(&query, common_importables_path, true) {
                continue;
            }
-            let common_importables_path_fst = fst_path(common_importables_path);
+            // Path shared by the importable items in this group.
+            let common_importables_path_fst = fst_path(&common_importable_data.path);
            // Add the items from this `ModPath` group. Those are all subsequent items in
            // `importables` whose paths match `path`.
            let iter = importables
@@ -387,7 +414,7 @@ pub fn search_dependencies<'a>(
                })
                .filter(|item| {
                    !query.case_sensitive // we've already checked the common importables path case-insensitively
-                        || contains_query(&query, &import_map.map[item].path, false)
+                        || query.import_matches(&import_map.map[item], false)
                });
            res.extend(iter);
@@ -398,19 +425,6 @@ pub fn search_dependencies<'a>(
        }
    }
-    // Add all exported associated items whose names match the query (exactly).
-    for map in &import_maps {
-        if let Some(v) = map.assoc_map.get(&*query.query) {
-            res.extend(v.iter().map(|&assoc| {
-                ItemInNs::Types(match assoc {
-                    AssocItemId::FunctionId(it) => it.into(),
-                    AssocItemId::ConstId(it) => it.into(),
-                    AssocItemId::TypeAliasId(it) => it.into(),
-                })
-            }));
-        }
-    }
    res
 }
@@ -432,9 +446,9 @@ fn item_import_kind(item: ItemInNs) -> Option<ImportKind> {
 mod tests {
    use base_db::{fixture::WithFixture, SourceDatabase, Upcast};
    use expect_test::{expect, Expect};
-    use stdx::format_to;
+    use test_utils::mark;
-    use crate::{data::FunctionData, test_db::TestDB, AssocContainerId, Lookup};
+    use crate::{test_db::TestDB, AssocContainerId, Lookup};
    use super::*;
@@ -451,46 +465,66 @@ mod tests {
        let actual = search_dependencies(db.upcast(), krate, query)
            .into_iter()
-            .filter_map(|item| {
+            .filter_map(|dependency| {
-                let mark = match item {
+                let dependency_krate = dependency.krate(db.upcast())?;
-                    ItemInNs::Types(ModuleDefId::FunctionId(_))
+                let dependency_imports = db.import_map(dependency_krate);
-                    | ItemInNs::Values(ModuleDefId::FunctionId(_)) => "f",
-                    ItemInNs::Types(_) => "t",
+                let (path, mark) = match assoc_item_path(&db, &dependency_imports, dependency) {
-                    ItemInNs::Values(_) => "v",
+                    Some(assoc_item_path) => (assoc_item_path, "a"),
-                    ItemInNs::Macros(_) => "m",
+                    None => (
+                        dependency_imports.path_of(dependency)?.to_string(),
+                        match dependency {
+                            ItemInNs::Types(ModuleDefId::FunctionId(_))
+                            | ItemInNs::Values(ModuleDefId::FunctionId(_)) => "f",
+                            ItemInNs::Types(_) => "t",
+                            ItemInNs::Values(_) => "v",
+                            ItemInNs::Macros(_) => "m",
+                        },
+                    ),
                };
-                item.krate(db.upcast()).map(|krate| {
-                    let map = db.import_map(krate);
+                Some(format!(
+                    "{}::{} ({})\n",
-                    let path = match assoc_to_trait(&db, item) {
+                    crate_graph[dependency_krate].display_name.as_ref()?,
-                        Some(trait_) => {
+                    path,
-                            let mut full_path = map.path_of(trait_).unwrap().to_string();
+                    mark
-                            if let ItemInNs::Types(ModuleDefId::FunctionId(function_id))
+                ))
-                            | ItemInNs::Values(ModuleDefId::FunctionId(function_id)) = item
-                            {
-                                format_to!(
-                                    full_path,
-                                    "::{}",
-                                    FunctionData::fn_data_query(&db, function_id).name,
-                                );
-                            }
-                            full_path
-                        }
-                        None => map.path_of(item).unwrap().to_string(),
-                    };
-                    format!(
-                        "{}::{} ({})\n",
-                        crate_graph[krate].display_name.as_ref().unwrap(),
-                        path,
-                        mark
-                    )
-                })
            })
            .collect::<String>();
        expect.assert_eq(&actual)
    }
+    fn assoc_item_path(
+        db: &dyn DefDatabase,
+        dependency_imports: &ImportMap,
+        dependency: ItemInNs,
+    ) -> Option<String> {
+        let dependency_assoc_item_id = match dependency {
+            ItemInNs::Types(ModuleDefId::FunctionId(id))
+            | ItemInNs::Values(ModuleDefId::FunctionId(id)) => AssocItemId::from(id),
+            ItemInNs::Types(ModuleDefId::ConstId(id))
+            | ItemInNs::Values(ModuleDefId::ConstId(id)) => AssocItemId::from(id),
+            ItemInNs::Types(ModuleDefId::TypeAliasId(id))
+            | ItemInNs::Values(ModuleDefId::TypeAliasId(id)) => AssocItemId::from(id),
+            _ => return None,
+        };
+        let trait_ = assoc_to_trait(db, dependency)?;
+        if let ModuleDefId::TraitId(tr) = trait_.as_module_def_id()? {
+            let trait_data = db.trait_data(tr);
+            let assoc_item_name =
+                trait_data.items.iter().find_map(|(assoc_item_name, assoc_item_id)| {
+                    if &dependency_assoc_item_id == assoc_item_id {
+                        Some(assoc_item_name)
+                    } else {
+                        None
+                    }
+                })?;
+            return Some(format!("{}::{}", dependency_imports.path_of(trait_)?, assoc_item_name));
+        }
+        None
+    }
    fn assoc_to_trait(db: &dyn DefDatabase, item: ItemInNs) -> Option<ItemInNs> {
        let assoc: AssocItemId = match item {
            ItemInNs::Types(it) | ItemInNs::Values(it) => match it {
@@ -749,6 +783,37 @@ mod tests {
    }
    #[test]
+    fn fuzzy_import_trait_and_assoc_items() {
+        mark::check!(type_aliases_ignored);
+        let ra_fixture = r#"
+        //- /main.rs crate:main deps:dep
+        //- /dep.rs crate:dep
+        pub mod fmt {
+            pub trait Display {
+                type FmtTypeAlias;
+                const FMT_CONST: bool;
+                fn format_function();
+                fn format_method(&self);
+            }
+        }
+    "#;
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("fmt".to_string()).search_mode(SearchMode::Fuzzy),
+            expect![[r#"
+                dep::fmt (t)
+                dep::fmt::Display (t)
+                dep::fmt::Display::FMT_CONST (a)
+                dep::fmt::Display::format_function (a)
+                dep::fmt::Display::format_method (a)
+            "#]],
+        );
+    }
+    #[test]
    fn search_mode() {
        let ra_fixture = r#"
            //- /main.rs crate:main deps:dep
@@ -784,8 +849,8 @@ mod tests {
                dep::Fmt (v)
                dep::Fmt (m)
                dep::fmt::Display (t)
+                dep::fmt::Display::fmt (a)
                dep::format (f)
-                dep::fmt::Display::fmt (f)
            "#]],
        );
@@ -798,7 +863,7 @@ mod tests {
                dep::Fmt (t)
                dep::Fmt (v)
                dep::Fmt (m)
-                dep::fmt::Display::fmt (f)
+                dep::fmt::Display::fmt (a)
            "#]],
        );
@@ -812,7 +877,7 @@ mod tests {
                dep::Fmt (v)
                dep::Fmt (m)
                dep::fmt::Display (t)
-                dep::fmt::Display::fmt (f)
+                dep::fmt::Display::fmt (a)
            "#]],
        );
    }
@@ -853,7 +918,7 @@ mod tests {
                dep::Fmt (v)
                dep::Fmt (m)
                dep::fmt::Display (t)
-                dep::fmt::Display::fmt (f)
+                dep::fmt::Display::fmt (a)
            "#]],
        );
@@ -866,7 +931,7 @@ mod tests {
                dep::Fmt (t)
                dep::Fmt (v)
                dep::Fmt (m)
-                dep::fmt::Display::fmt (f)
+                dep::fmt::Display::fmt (a)
            "#]],
        );
    }
diff --git a/crates/hir_def/src/item_scope.rs b/crates/hir_def/src/item_scope.rs
index 62ab3b2bd..2750e1c91 100644
--- a/crates/hir_def/src/item_scope.rs
+++ b/crates/hir_def/src/item_scope.rs
@@ -10,10 +10,9 @@ use once_cell::sync::Lazy;
 use rustc_hash::{FxHashMap, FxHashSet};
 use test_utils::mark;
-use crate::ModuleId;
 use crate::{
    db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, HasModule, ImplId,
-    LocalModuleId, Lookup, MacroDefId, ModuleDefId, TraitId,
+    LocalModuleId, Lookup, MacroDefId, ModuleDefId, ModuleId, TraitId,
 };
 #[derive(Copy, Clone)]
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index a636ec77d..77017e4ea 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -13,7 +13,7 @@ use hir_expand::{
    builtin_macro::find_builtin_macro,
    name::{AsName, Name},
    proc_macro::ProcMacroExpander,
-    HirFileId, MacroCallId, MacroDefId, MacroDefKind,
+    HirFileId, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
 };
 use hir_expand::{InFile, MacroCallLoc};
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -860,6 +860,37 @@ impl DefCollector<'_> {
    }
    fn finish(mut self) -> CrateDefMap {
+        // Emit diagnostics for all remaining unexpanded macros.
+        for directive in &self.unexpanded_macros {
+            let mut error = None;
+            directive.ast_id.as_call_id_with_errors(
+                self.db,
+                self.def_map.krate,
+                |path| {
+                    let resolved_res = self.def_map.resolve_path_fp_with_macro(
+                        self.db,
+                        ResolveMode::Other,
+                        directive.module_id,
+                        &path,
+                        BuiltinShadowMode::Module,
+                    );
+                    resolved_res.resolved_def.take_macros()
+                },
+                &mut |e| {
+                    error.get_or_insert(e);
+                },
+            );
+            if let Some(err) = error {
+                self.def_map.diagnostics.push(DefDiagnostic::macro_error(
+                    directive.module_id,
+                    MacroCallKind::FnLike(directive.ast_id.ast_id),
+                    err.to_string(),
+                ));
+            }
+        }
        // Emit diagnostics for all remaining unresolved imports.
        // We'd like to avoid emitting a diagnostics avalanche when some `extern crate` doesn't
diff --git a/crates/hir_expand/src/proc_macro.rs b/crates/hir_expand/src/proc_macro.rs
index 7c77f6ce0..1923daca5 100644
--- a/crates/hir_expand/src/proc_macro.rs
+++ b/crates/hir_expand/src/proc_macro.rs
@@ -58,7 +58,7 @@ impl ProcMacroExpander {
 }
 fn eat_punct(cursor: &mut Cursor, c: char) -> bool {
-    if let Some(tt::TokenTree::Leaf(tt::Leaf::Punct(punct))) = cursor.token_tree() {
+    if let Some(tt::buffer::TokenTreeRef::Leaf(tt::Leaf::Punct(punct), _)) = cursor.token_tree() {
        if punct.char == c {
            *cursor = cursor.bump();
            return true;
@@ -68,7 +68,7 @@ fn eat_punct(cursor: &mut Cursor, c: char) -> bool {
 }
 fn eat_subtree(cursor: &mut Cursor, kind: tt::DelimiterKind) -> bool {
-    if let Some(tt::TokenTree::Subtree(subtree)) = cursor.token_tree() {
+    if let Some(tt::buffer::TokenTreeRef::Subtree(subtree, _)) = cursor.token_tree() {
        if Some(kind) == subtree.delimiter_kind() {
            *cursor = cursor.bump_subtree();
            return true;
@@ -78,7 +78,7 @@ fn eat_subtree(cursor: &mut Cursor, kind: tt::DelimiterKind) -> bool {
 }
 fn eat_ident(cursor: &mut Cursor, t: &str) -> bool {
-    if let Some(tt::TokenTree::Leaf(tt::Leaf::Ident(ident))) = cursor.token_tree() {
+    if let Some(tt::buffer::TokenTreeRef::Leaf(tt::Leaf::Ident(ident), _)) = cursor.token_tree() {
        if t == ident.text.as_str() {
            *cursor = cursor.bump();
            return true;
@@ -88,7 +88,7 @@ fn eat_ident(cursor: &mut Cursor, t: &str) -> bool {
 }
 fn remove_derive_attrs(tt: &tt::Subtree) -> Option<tt::Subtree> {
-    let buffer = TokenBuffer::new(&tt.token_trees);
+    let buffer = TokenBuffer::from_tokens(&tt.token_trees);
    let mut p = buffer.begin();
    let mut result = tt::Subtree::default();
@@ -106,7 +106,7 @@ fn remove_derive_attrs(tt: &tt::Subtree) -> Option<tt::Subtree> {
            }
        }
-        result.token_trees.push(curr.token_tree()?.clone());
+        result.token_trees.push(curr.token_tree()?.cloned());
        p = curr.bump();
    }
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index 3d1778590..b0a453961 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -17,9 +17,9 @@ ena = "0.14.0"
 log = "0.4.8"
 rustc-hash = "1.1.0"
 scoped-tls = "1"
-chalk-solve = { version = "0.45", default-features = false }
+chalk-solve = { version = "0.47", default-features = false }
-chalk-ir = "0.45"
+chalk-ir = "0.47"
-chalk-recursive = "0.45"
+chalk-recursive = "0.47"
 stdx = { path = "../stdx", version = "0.0.0" }
 hir_def = { path = "../hir_def", version = "0.0.0" }
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index 0e827a29e..e9e949c47 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -168,7 +168,7 @@ pub enum DisplayTarget {
 impl DisplayTarget {
    fn is_source_code(&self) -> bool {
-        matches!(self, Self::SourceCode {..})
+        matches!(self, Self::SourceCode { .. })
    }
    fn is_test(&self) -> bool {
        matches!(self, Self::Test)
@@ -595,7 +595,7 @@ impl HirDisplay for FnSig {
    }
 }
-fn write_bounds_like_dyn_trait(
+pub fn write_bounds_like_dyn_trait(
    predicates: &[GenericPredicate],
    f: &mut HirFormatter,
 ) -> Result<(), HirDisplayError> {
diff --git a/crates/ide/src/display/short_label.rs b/crates/ide/src/display/short_label.rs
index ea49d9f97..990f740b8 100644
--- a/crates/ide/src/display/short_label.rs
+++ b/crates/ide/src/display/short_label.rs
@@ -87,6 +87,17 @@ impl ShortLabel for ast::Variant {
    }
 }
+impl ShortLabel for ast::ConstParam {
+    fn short_label(&self) -> Option<String> {
+        let mut buf = "const ".to_owned();
+        buf.push_str(self.name()?.text().as_str());
+        if let Some(type_ref) = self.ty() {
+            format_to!(buf, ": {}", type_ref.syntax());
+        }
+        Some(buf)
+    }
+}
 fn short_label_from_ty<T>(node: &T, ty: Option<ast::Type>, prefix: &str) -> Option<String>
 where
    T: NameOwner + VisibilityOwner,
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 2737c900f..f2ad95cb6 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -70,7 +70,7 @@ impl HoverConfig {
 #[derive(Debug, Clone)]
 pub enum HoverAction {
    Runnable(Runnable),
-    Implementaion(FilePosition),
+    Implementation(FilePosition),
    GoToType(Vec<HoverGotoTypeData>),
 }
@@ -116,12 +116,13 @@ pub(crate) fn hover(
    };
    if let Some(definition) = definition {
        if let Some(markup) = hover_for_definition(db, definition) {
+            let markup = markup.as_str();
            let markup = if !markdown {
-                remove_markdown(&markup.as_str())
+                remove_markdown(markup)
            } else if links_in_hover {
-                rewrite_links(db, &markup.as_str(), &definition)
+                rewrite_links(db, markup, &definition)
            } else {
-                remove_links(&markup.as_str())
+                remove_links(markup)
            };
            res.markup = Markup::from(markup);
            if let Some(action) = show_implementations_action(db, definition) {
@@ -175,22 +176,24 @@ pub(crate) fn hover(
 fn show_implementations_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> {
    fn to_action(nav_target: NavigationTarget) -> HoverAction {
-        HoverAction::Implementaion(FilePosition {
+        HoverAction::Implementation(FilePosition {
            file_id: nav_target.file_id,
            offset: nav_target.focus_or_full_range().start(),
        })
    }
-    match def {
+    let adt = match def {
-        Definition::ModuleDef(it) => match it {
+        Definition::ModuleDef(ModuleDef::Trait(it)) => return it.try_to_nav(db).map(to_action),
-            ModuleDef::Adt(Adt::Struct(it)) => Some(to_action(it.try_to_nav(db)?)),
+        Definition::ModuleDef(ModuleDef::Adt(it)) => Some(it),
-            ModuleDef::Adt(Adt::Union(it)) => Some(to_action(it.try_to_nav(db)?)),
+        Definition::SelfType(it) => it.target_ty(db).as_adt(),
-            ModuleDef::Adt(Adt::Enum(it)) => Some(to_action(it.try_to_nav(db)?)),
-            ModuleDef::Trait(it) => Some(to_action(it.try_to_nav(db)?)),
-            _ => None,
-        },
        _ => None,
+    }?;
+    match adt {
+        Adt::Struct(it) => it.try_to_nav(db),
+        Adt::Union(it) => it.try_to_nav(db),
+        Adt::Enum(it) => it.try_to_nav(db),
    }
+    .map(to_action)
 }
 fn runnable_action(
@@ -225,45 +228,46 @@ fn runnable_action(
 }
 fn goto_type_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> {
-    match def {
+    let mut targets: Vec<ModuleDef> = Vec::new();
-        Definition::Local(it) => {
+    let mut push_new_def = |item: ModuleDef| {
-            let mut targets: Vec<ModuleDef> = Vec::new();
+        if !targets.contains(&item) {
-            let mut push_new_def = |item: ModuleDef| {
+            targets.push(item);
-                if !targets.contains(&item) {
-                    targets.push(item);
-                }
-            };
-            it.ty(db).walk(db, |t| {
-                if let Some(adt) = t.as_adt() {
-                    push_new_def(adt.into());
-                } else if let Some(trait_) = t.as_dyn_trait() {
-                    push_new_def(trait_.into());
-                } else if let Some(traits) = t.as_impl_traits(db) {
-                    traits.into_iter().for_each(|it| push_new_def(it.into()));
-                } else if let Some(trait_) = t.as_associated_type_parent_trait(db) {
-                    push_new_def(trait_.into());
-                }
-            });
-            let targets = targets
-                .into_iter()
-                .filter_map(|it| {
-                    Some(HoverGotoTypeData {
-                        mod_path: render_path(
-                            db,
-                            it.module(db)?,
-                            it.name(db).map(|name| name.to_string()),
-                        ),
-                        nav: it.try_to_nav(db)?,
-                    })
-                })
-                .collect();
-            Some(HoverAction::GoToType(targets))
        }
-        _ => None,
+    };
+    if let Definition::TypeParam(it) = def {
+        it.trait_bounds(db).into_iter().for_each(|it| push_new_def(it.into()));
+    } else {
+        let ty = match def {
+            Definition::Local(it) => it.ty(db),
+            Definition::ConstParam(it) => it.ty(db),
+            _ => return None,
+        };
+        ty.walk(db, |t| {
+            if let Some(adt) = t.as_adt() {
+                push_new_def(adt.into());
+            } else if let Some(trait_) = t.as_dyn_trait() {
+                push_new_def(trait_.into());
+            } else if let Some(traits) = t.as_impl_traits(db) {
+                traits.into_iter().for_each(|it| push_new_def(it.into()));
+            } else if let Some(trait_) = t.as_associated_type_parent_trait(db) {
+                push_new_def(trait_.into());
+            }
+        });
    }
+    let targets = targets
+        .into_iter()
+        .filter_map(|it| {
+            Some(HoverGotoTypeData {
+                mod_path: render_path(db, it.module(db)?, it.name(db).map(|name| name.to_string())),
+                nav: it.try_to_nav(db)?,
+            })
+        })
+        .collect();
+    Some(HoverAction::GoToType(targets))
 }
 fn hover_markup(
@@ -370,10 +374,8 @@ fn hover_for_definition(db: &RootDatabase, def: Definition) -> Option<Markup> {
        }
        Definition::Label(it) => Some(Markup::fenced_block(&it.name(db))),
        Definition::LifetimeParam(it) => Some(Markup::fenced_block(&it.name(db))),
-        Definition::TypeParam(_) | Definition::ConstParam(_) => {
+        Definition::TypeParam(type_param) => Some(Markup::fenced_block(&type_param.display(db))),
-            // FIXME: Hover for generic param
+        Definition::ConstParam(it) => from_def_source(db, it, None),
-            None
-        }
    };
    fn from_def_source<A, D>(db: &RootDatabase, def: D, mod_path: Option<String>) -> Option<Markup>
@@ -1393,7 +1395,7 @@ fn bar() { fo<|>o(); }
            r"unsafe trait foo<|>() {}",
            expect![[r#"
                [
-                    Implementaion(
+                    Implementation(
                        FilePosition {
                            file_id: FileId(
                                0,
@@ -2105,7 +2107,7 @@ fn foo() { let bar = Bar; bar.fo<|>o(); }
            r#"trait foo<|>() {}"#,
            expect![[r#"
                [
-                    Implementaion(
+                    Implementation(
                        FilePosition {
                            file_id: FileId(
                                0,
@@ -2124,7 +2126,7 @@ fn foo() { let bar = Bar; bar.fo<|>o(); }
            r"struct foo<|>() {}",
            expect![[r#"
                [
-                    Implementaion(
+                    Implementation(
                        FilePosition {
                            file_id: FileId(
                                0,
@@ -2143,7 +2145,7 @@ fn foo() { let bar = Bar; bar.fo<|>o(); }
            r#"union foo<|>() {}"#,
            expect![[r#"
                [
-                    Implementaion(
+                    Implementation(
                        FilePosition {
                            file_id: FileId(
                                0,
@@ -2162,7 +2164,7 @@ fn foo() { let bar = Bar; bar.fo<|>o(); }
            r"enum foo<|>() { A, B }",
            expect![[r#"
                [
-                    Implementaion(
+                    Implementation(
                        FilePosition {
                            file_id: FileId(
                                0,
@@ -2176,6 +2178,25 @@ fn foo() { let bar = Bar; bar.fo<|>o(); }
    }
    #[test]
+    fn test_hover_self_has_impl_action() {
+        check_actions(
+            r#"struct foo where Self<|>:;"#,
+            expect![[r#"
+                [
+                    Implementation(
+                        FilePosition {
+                            file_id: FileId(
+                                0,
+                            ),
+                            offset: 7,
+                        },
+                    ),
+                ]
+            "#]],
+        );
+    }
+    #[test]
    fn test_hover_test_has_action() {
        check_actions(
            r#"
@@ -3064,6 +3085,71 @@ fn main() { let s<|>t = test().get(); }
    }
    #[test]
+    fn test_hover_const_param_has_goto_type_action() {
+        check_actions(
+            r#"
+struct Bar;
+struct Foo<const BAR: Bar>;
+impl<const BAR: Bar> Foo<BAR<|>> {}
+"#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "test::Bar",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 0..11,
+                                    focus_range: 7..10,
+                                    name: "Bar",
+                                    kind: Struct,
+                                    description: "struct Bar",
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+    #[test]
+    fn test_hover_type_param_has_goto_type_action() {
+        check_actions(
+            r#"
+trait Foo {}
+fn foo<T: Foo>(t: T<|>){}
+"#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "test::Foo",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 0..12,
+                                    focus_range: 6..9,
+                                    name: "Foo",
+                                    kind: Trait,
+                                    description: "trait Foo",
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+    #[test]
    fn hover_displays_normalized_crate_names() {
        check(
            r#"
@@ -3257,4 +3343,68 @@ fn foo() {
            "#]],
        );
    }
+    #[test]
+    fn hover_type_param() {
+        check(
+            r#"
+struct Foo<T>(T);
+trait Copy {}
+trait Clone {}
+trait Sized {}
+impl<T: Copy + Clone> Foo<T<|>> where T: Sized {}
+"#,
+            expect![[r#"
+                *T*
+                ```rust
+                T: Copy + Clone + Sized
+                ```
+            "#]],
+        );
+        check(
+            r#"
+struct Foo<T>(T);
+impl<T> Foo<T<|>> {}
+"#,
+            expect![[r#"
+                *T*
+                ```rust
+                T
+                ```
+                "#]],
+        );
+        // lifetimes aren't being substituted yet
+        check(
+            r#"
+struct Foo<T>(T);
+impl<T: 'static> Foo<T<|>> {}
+"#,
+            expect![[r#"
+                *T*
+                ```rust
+                T: {error}
+                ```
+                "#]],
+        );
+    }
+    #[test]
+    fn hover_const_param() {
+        check(
+            r#"
+struct Foo<const LEN: usize>;
+impl<const LEN: usize> Foo<LEN<|>> {}
+"#,
+            expect![[r#"
+                *LEN*
+                ```rust
+                const LEN: usize
+                ```
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide_db/src/imports_locator.rs b/crates/ide_db/src/imports_locator.rs
index 0f4c2ca47..0782ab070 100644
--- a/crates/ide_db/src/imports_locator.rs
+++ b/crates/ide_db/src/imports_locator.rs
@@ -1,7 +1,7 @@
 //! This module contains an import search funcionality that is provided to the assists module.
 //! Later, this should be moved away to a separate crate that is accessible from the assists module.
-use hir::{import_map, Crate, MacroDef, ModuleDef, Semantics};
+use hir::{import_map, AsAssocItem, Crate, MacroDef, ModuleDef, Semantics};
 use syntax::{ast, AstNode, SyntaxKind::NAME};
 use crate::{
@@ -40,8 +40,9 @@ pub fn find_similar_imports<'a>(
    krate: Crate,
    limit: Option<usize>,
    fuzzy_search_string: String,
+    ignore_assoc_items: bool,
    name_only: bool,
-) -> impl Iterator<Item = Either<ModuleDef, MacroDef>> {
+) -> impl Iterator<Item = Either<ModuleDef, MacroDef>> + 'a {
    let _p = profile::span("find_similar_imports");
    let mut external_query = import_map::Query::new(fuzzy_search_string.clone())
@@ -57,7 +58,21 @@ pub fn find_similar_imports<'a>(
        external_query = external_query.limit(limit);
    }
-    find_imports(sema, krate, local_query, external_query)
+    let db = sema.db;
+    find_imports(sema, krate, local_query, external_query).filter(move |import_candidate| {
+        if ignore_assoc_items {
+            match import_candidate {
+                Either::Left(ModuleDef::Function(function)) => function.as_assoc_item(db).is_none(),
+                Either::Left(ModuleDef::Const(const_)) => const_.as_assoc_item(db).is_none(),
+                Either::Left(ModuleDef::TypeAlias(type_alias)) => {
+                    type_alias.as_assoc_item(db).is_none()
+                }
+                _ => true,
+            }
+        } else {
+            true
+        }
+    })
 }
 fn find_imports<'a>(
diff --git a/crates/mbe/src/mbe_expander/matcher.rs b/crates/mbe/src/mbe_expander/matcher.rs
index ab5f87c48..fdc8844ce 100644
--- a/crates/mbe/src/mbe_expander/matcher.rs
+++ b/crates/mbe/src/mbe_expander/matcher.rs
@@ -309,7 +309,7 @@ impl<'a> TtIter<'a> {
            }
        }
-        let buffer = TokenBuffer::new(&self.inner.as_slice());
+        let buffer = TokenBuffer::from_tokens(&self.inner.as_slice());
        let mut src = SubtreeTokenSource::new(&buffer);
        let mut sink = OffsetTokenSink { cursor: buffer.begin(), error: false };
@@ -336,11 +336,11 @@ impl<'a> TtIter<'a> {
            err = Some(err!("no tokens consumed"));
        }
        let res = match res.len() {
-            1 => Some(res[0].clone()),
+            1 => Some(res[0].cloned()),
            0 => None,
            _ => Some(tt::TokenTree::Subtree(tt::Subtree {
                delimiter: None,
-                token_trees: res.into_iter().cloned().collect(),
+                token_trees: res.into_iter().map(|it| it.cloned()).collect(),
            })),
        };
        ExpandResult { value: res, err }
diff --git a/crates/mbe/src/subtree_source.rs b/crates/mbe/src/subtree_source.rs
index d10d4b70e..d7433bd35 100644
--- a/crates/mbe/src/subtree_source.rs
+++ b/crates/mbe/src/subtree_source.rs
@@ -1,129 +1,104 @@
 //! FIXME: write short doc here
 use parser::{Token, TokenSource};
-use std::cell::{Cell, Ref, RefCell};
 use syntax::{lex_single_syntax_kind, SmolStr, SyntaxKind, SyntaxKind::*, T};
-use tt::buffer::{Cursor, TokenBuffer};
+use tt::buffer::TokenBuffer;
 #[derive(Debug, Clone, Eq, PartialEq)]
 struct TtToken {
-    kind: SyntaxKind,
+    tt: Token,
-    is_joint_to_next: bool,
    text: SmolStr,
 }
-pub(crate) struct SubtreeTokenSource<'a> {
+pub(crate) struct SubtreeTokenSource {
-    cached_cursor: Cell<Cursor<'a>>,
+    cached: Vec<TtToken>,
-    cached: RefCell<Vec<Option<TtToken>>>,
    curr: (Token, usize),
 }
-impl<'a> SubtreeTokenSource<'a> {
+impl<'a> SubtreeTokenSource {
    // Helper function used in test
    #[cfg(test)]
    pub(crate) fn text(&self) -> SmolStr {
-        match *self.get(self.curr.1) {
+        match self.cached.get(self.curr.1) {
            Some(ref tt) => tt.text.clone(),
            _ => SmolStr::new(""),
        }
    }
 }
-impl<'a> SubtreeTokenSource<'a> {
+impl<'a> SubtreeTokenSource {
-    pub(crate) fn new(buffer: &'a TokenBuffer) -> SubtreeTokenSource<'a> {
+    pub(crate) fn new(buffer: &TokenBuffer) -> SubtreeTokenSource {
-        let cursor = buffer.begin();
+        let mut current = buffer.begin();
+        let mut cached = Vec::with_capacity(100);
-        let mut res = SubtreeTokenSource {
+        while !current.eof() {
-            curr: (Token { kind: EOF, is_jointed_to_next: false }, 0),
+            let cursor = current;
-            cached_cursor: Cell::new(cursor),
+            let tt = cursor.token_tree();
-            cached: RefCell::new(Vec::with_capacity(10)),
-        };
-        res.curr = (res.mk_token(0), 0);
-        res
-    }
-    fn mk_token(&self, pos: usize) -> Token {
+            // Check if it is lifetime
-        match *self.get(pos) {
+            if let Some(tt::buffer::TokenTreeRef::Leaf(tt::Leaf::Punct(punct), _)) = tt {
-            Some(ref tt) => Token { kind: tt.kind, is_jointed_to_next: tt.is_joint_to_next },
-            None => Token { kind: EOF, is_jointed_to_next: false },
-        }
-    }
-    fn get(&self, pos: usize) -> Ref<Option<TtToken>> {
-        fn is_lifetime(c: Cursor) -> Option<(Cursor, SmolStr)> {
-            let tkn = c.token_tree();
-            if let Some(tt::TokenTree::Leaf(tt::Leaf::Punct(punct))) = tkn {
                if punct.char == '\'' {
-                    let next = c.bump();
+                    let next = cursor.bump();
-                    if let Some(tt::TokenTree::Leaf(tt::Leaf::Ident(ident))) = next.token_tree() {
+                    if let Some(tt::buffer::TokenTreeRef::Leaf(tt::Leaf::Ident(ident), _)) =
-                        let res_cursor = next.bump();
+                        next.token_tree()
-                        let text = SmolStr::new("'".to_string() + &ident.to_string());
+                    {
+                        let text = SmolStr::new("'".to_string() + &ident.text);
-                        return Some((res_cursor, text));
+                        cached.push(TtToken {
+                            tt: Token { kind: LIFETIME_IDENT, is_jointed_to_next: false },
+                            text,
+                        });
+                        current = next.bump();
+                        continue;
                    } else {
                        panic!("Next token must be ident : {:#?}", next.token_tree());
                    }
                }
            }
-            None
+            current = match tt {
-        }
+                Some(tt::buffer::TokenTreeRef::Leaf(leaf, _)) => {
+                    cached.push(convert_leaf(&leaf));
-        if pos < self.cached.borrow().len() {
+                    cursor.bump()
-            return Ref::map(self.cached.borrow(), |c| &c[pos]);
-        }
-        {
-            let mut cached = self.cached.borrow_mut();
-            while pos >= cached.len() {
-                let cursor = self.cached_cursor.get();
-                if cursor.eof() {
-                    cached.push(None);
-                    continue;
                }
+                Some(tt::buffer::TokenTreeRef::Subtree(subtree, _)) => {
-                if let Some((curr, text)) = is_lifetime(cursor) {
+                    cached.push(convert_delim(subtree.delimiter_kind(), false));
-                    cached.push(Some(TtToken {
+                    cursor.subtree().unwrap()
-                        kind: LIFETIME_IDENT,
-                        is_joint_to_next: false,
-                        text,
-                    }));
-                    self.cached_cursor.set(curr);
-                    continue;
                }
+                None => {
-                match cursor.token_tree() {
+                    if let Some(subtree) = cursor.end() {
-                    Some(tt::TokenTree::Leaf(leaf)) => {
+                        cached.push(convert_delim(subtree.delimiter_kind(), true));
-                        cached.push(Some(convert_leaf(&leaf)));
+                        cursor.bump()
-                        self.cached_cursor.set(cursor.bump());
+                    } else {
-                    }
+                        continue;
-                    Some(tt::TokenTree::Subtree(subtree)) => {
-                        self.cached_cursor.set(cursor.subtree().unwrap());
-                        cached.push(Some(convert_delim(subtree.delimiter_kind(), false)));
-                    }
-                    None => {
-                        if let Some(subtree) = cursor.end() {
-                            cached.push(Some(convert_delim(subtree.delimiter_kind(), true)));
-                            self.cached_cursor.set(cursor.bump());
-                        }
                    }
                }
-            }
+            };
        }
-        Ref::map(self.cached.borrow(), |c| &c[pos])
+        let mut res = SubtreeTokenSource {
+            curr: (Token { kind: EOF, is_jointed_to_next: false }, 0),
+            cached,
+        };
+        res.curr = (res.token(0), 0);
+        res
+    }
+    fn token(&self, pos: usize) -> Token {
+        match self.cached.get(pos) {
+            Some(it) => it.tt,
+            None => Token { kind: EOF, is_jointed_to_next: false },
+        }
    }
 }
-impl<'a> TokenSource for SubtreeTokenSource<'a> {
+impl<'a> TokenSource for SubtreeTokenSource {
    fn current(&self) -> Token {
        self.curr.0
    }
    /// Lookahead n token
    fn lookahead_nth(&self, n: usize) -> Token {
-        self.mk_token(self.curr.1 + n)
+        self.token(self.curr.1 + n)
    }
    /// bump cursor to next token
@@ -131,13 +106,12 @@ impl<'a> TokenSource for SubtreeTokenSource<'a> {
        if self.current().kind == EOF {
            return;
        }
+        self.curr = (self.token(self.curr.1 + 1), self.curr.1 + 1);
-        self.curr = (self.mk_token(self.curr.1 + 1), self.curr.1 + 1);
    }
    /// Is the current token a specified keyword?
    fn is_keyword(&self, kw: &str) -> bool {
-        match *self.get(self.curr.1) {
+        match self.cached.get(self.curr.1) {
            Some(ref t) => t.text == *kw,
            _ => false,
        }
@@ -155,7 +129,7 @@ fn convert_delim(d: Option<tt::DelimiterKind>, closing: bool) -> TtToken {
    let idx = closing as usize;
    let kind = kinds[idx];
    let text = if !texts.is_empty() { &texts[idx..texts.len() - (1 - idx)] } else { "" };
-    TtToken { kind, is_joint_to_next: false, text: SmolStr::new(text) }
+    TtToken { tt: Token { kind, is_jointed_to_next: false }, text: SmolStr::new(text) }
 }
 fn convert_literal(l: &tt::Literal) -> TtToken {
@@ -169,7 +143,7 @@ fn convert_literal(l: &tt::Literal) -> TtToken {
        })
        .unwrap_or_else(|| panic!("Fail to convert given literal {:#?}", &l));
-    TtToken { kind, is_joint_to_next: false, text: l.text.clone() }
+    TtToken { tt: Token { kind, is_jointed_to_next: false }, text: l.text.clone() }
 }
 fn convert_ident(ident: &tt::Ident) -> TtToken {
@@ -180,7 +154,7 @@ fn convert_ident(ident: &tt::Ident) -> TtToken {
        _ => SyntaxKind::from_keyword(ident.text.as_str()).unwrap_or(IDENT),
    };
-    TtToken { kind, is_joint_to_next: false, text: ident.text.clone() }
+    TtToken { tt: Token { kind, is_jointed_to_next: false }, text: ident.text.clone() }
 }
 fn convert_punct(p: tt::Punct) -> TtToken {
@@ -194,7 +168,7 @@ fn convert_punct(p: tt::Punct) -> TtToken {
        let s: &str = p.char.encode_utf8(&mut buf);
        SmolStr::new(s)
    };
-    TtToken { kind, is_joint_to_next: p.spacing == tt::Spacing::Joint, text }
+    TtToken { tt: Token { kind, is_jointed_to_next: p.spacing == tt::Spacing::Joint }, text }
 }
 fn convert_leaf(leaf: &tt::Leaf) -> TtToken {
@@ -208,6 +182,7 @@ fn convert_leaf(leaf: &tt::Leaf) -> TtToken {
 #[cfg(test)]
 mod tests {
    use super::{convert_literal, TtToken};
+    use parser::Token;
    use syntax::{SmolStr, SyntaxKind};
    #[test]
@@ -218,8 +193,7 @@ mod tests {
                text: SmolStr::new("-42.0")
            }),
            TtToken {
-                kind: SyntaxKind::FLOAT_NUMBER,
+                tt: Token { kind: SyntaxKind::FLOAT_NUMBER, is_jointed_to_next: false },
-                is_joint_to_next: false,
                text: SmolStr::new("-42.0")
            }
        );
diff --git a/crates/mbe/src/syntax_bridge.rs b/crates/mbe/src/syntax_bridge.rs
index 265c0d63d..671036e1c 100644
--- a/crates/mbe/src/syntax_bridge.rs
+++ b/crates/mbe/src/syntax_bridge.rs
@@ -70,15 +70,12 @@ pub fn token_tree_to_syntax_node(
    tt: &tt::Subtree,
    fragment_kind: FragmentKind,
 ) -> Result<(Parse<SyntaxNode>, TokenMap), ExpandError> {
-    let tmp;
+    let buffer = match tt {
-    let tokens = match tt {
+        tt::Subtree { delimiter: None, token_trees } => {
-        tt::Subtree { delimiter: None, token_trees } => token_trees.as_slice(),
+            TokenBuffer::from_tokens(token_trees.as_slice())
-        _ => {
-            tmp = [tt.clone().into()];
-            &tmp[..]
        }
+        _ => TokenBuffer::from_subtree(tt),
    };
-    let buffer = TokenBuffer::new(&tokens);
    let mut token_source = SubtreeTokenSource::new(&buffer);
    let mut tree_sink = TtTreeSink::new(buffer.begin());
    parser::parse_fragment(&mut token_source, &mut tree_sink, fragment_kind);
@@ -414,7 +411,7 @@ trait TokenConvertor {
    fn id_alloc(&mut self) -> &mut TokenIdAlloc;
 }
-impl<'a> SrcToken for (RawToken, &'a str) {
+impl<'a> SrcToken for (&'a RawToken, &'a str) {
    fn kind(&self) -> SyntaxKind {
        self.0.kind
    }
@@ -431,7 +428,7 @@ impl<'a> SrcToken for (RawToken, &'a str) {
 impl RawConvertor<'_> {}
 impl<'a> TokenConvertor for RawConvertor<'a> {
-    type Token = (RawToken, &'a str);
+    type Token = (&'a RawToken, &'a str);
    fn convert_doc_comment(&self, token: &Self::Token) -> Option<Vec<tt::TokenTree>> {
        convert_doc_comment(&doc_comment(token.1))
@@ -442,11 +439,11 @@ impl<'a> TokenConvertor for RawConvertor<'a> {
        let range = TextRange::at(self.offset, token.len);
        self.offset += token.len;
-        Some(((*token, &self.text[range]), range))
+        Some(((token, &self.text[range]), range))
    }
    fn peek(&self) -> Option<Self::Token> {
-        let token = self.inner.as_slice().get(0).cloned();
+        let token = self.inner.as_slice().get(0);
        token.map(|it| {
            let range = TextRange::at(self.offset, it.len);
@@ -601,17 +598,16 @@ impl<'a> TtTreeSink<'a> {
    }
 }
-fn delim_to_str(d: Option<tt::DelimiterKind>, closing: bool) -> SmolStr {
+fn delim_to_str(d: Option<tt::DelimiterKind>, closing: bool) -> &'static str {
    let texts = match d {
        Some(tt::DelimiterKind::Parenthesis) => "()",
        Some(tt::DelimiterKind::Brace) => "{}",
        Some(tt::DelimiterKind::Bracket) => "[]",
-        None => return "".into(),
+        None => return "",
    };
    let idx = closing as usize;
-    let text = &texts[idx..texts.len() - (1 - idx)];
+    &texts[idx..texts.len() - (1 - idx)]
-    text.into()
 }
 impl<'a> TreeSink for TtTreeSink<'a> {
@@ -626,29 +622,32 @@ impl<'a> TreeSink for TtTreeSink<'a> {
        let mut last = self.cursor;
        for _ in 0..n_tokens {
+            let tmp_str: SmolStr;
            if self.cursor.eof() {
                break;
            }
            last = self.cursor;
-            let text: SmolStr = match self.cursor.token_tree() {
+            let text: &str = match self.cursor.token_tree() {
-                Some(tt::TokenTree::Leaf(leaf)) => {
+                Some(tt::buffer::TokenTreeRef::Leaf(leaf, _)) => {
                    // Mark the range if needed
                    let (text, id) = match leaf {
-                        tt::Leaf::Ident(ident) => (ident.text.clone(), ident.id),
+                        tt::Leaf::Ident(ident) => (&ident.text, ident.id),
                        tt::Leaf::Punct(punct) => {
                            assert!(punct.char.is_ascii());
                            let char = &(punct.char as u8);
-                            let text = std::str::from_utf8(std::slice::from_ref(char)).unwrap();
+                            tmp_str = SmolStr::new_inline(
-                            (SmolStr::new_inline(text), punct.id)
+                                std::str::from_utf8(std::slice::from_ref(char)).unwrap(),
+                            );
+                            (&tmp_str, punct.id)
                        }
-                        tt::Leaf::Literal(lit) => (lit.text.clone(), lit.id),
+                        tt::Leaf::Literal(lit) => (&lit.text, lit.id),
                    };
                    let range = TextRange::at(self.text_pos, TextSize::of(text.as_str()));
                    self.token_map.insert(id, range);
                    self.cursor = self.cursor.bump();
                    text
                }
-                Some(tt::TokenTree::Subtree(subtree)) => {
+                Some(tt::buffer::TokenTreeRef::Subtree(subtree, _)) => {
                    self.cursor = self.cursor.subtree().unwrap();
                    if let Some(id) = subtree.delimiter.map(|it| it.id) {
                        self.open_delims.insert(id, self.text_pos);
@@ -672,7 +671,7 @@ impl<'a> TreeSink for TtTreeSink<'a> {
                }
            };
            self.buf += &text;
-            self.text_pos += TextSize::of(text.as_str());
+            self.text_pos += TextSize::of(text);
        }
        let text = SmolStr::new(self.buf.as_str());
@@ -682,8 +681,8 @@ impl<'a> TreeSink for TtTreeSink<'a> {
        // Add whitespace between adjoint puncts
        let next = last.bump();
        if let (
-            Some(tt::TokenTree::Leaf(tt::Leaf::Punct(curr))),
+            Some(tt::buffer::TokenTreeRef::Leaf(tt::Leaf::Punct(curr), _)),
-            Some(tt::TokenTree::Leaf(tt::Leaf::Punct(_))),
+            Some(tt::buffer::TokenTreeRef::Leaf(tt::Leaf::Punct(_), _)),
        ) = (last.token_tree(), next.token_tree())
        {
            // Note: We always assume the semi-colon would be the last token in
@@ -742,7 +741,7 @@ mod tests {
        )
        .expand_tt("literals!(foo);");
        let tts = &[expansion.into()];
-        let buffer = tt::buffer::TokenBuffer::new(tts);
+        let buffer = tt::buffer::TokenBuffer::from_tokens(tts);
        let mut tt_src = SubtreeTokenSource::new(&buffer);
        let mut tokens = vec![];
        while tt_src.current().kind != EOF {
diff --git a/crates/parser/src/grammar.rs b/crates/parser/src/grammar.rs
index 63cc90027..bb9ffea8b 100644
--- a/crates/parser/src/grammar.rs
+++ b/crates/parser/src/grammar.rs
@@ -66,6 +66,10 @@ pub(crate) mod fragments {
        expressions::stmt(p, expressions::StmtWithSemi::No)
    }
+    pub(crate) fn stmt_optional_semi(p: &mut Parser) {
+        expressions::stmt(p, expressions::StmtWithSemi::Optional)
+    }
    pub(crate) fn opt_visibility(p: &mut Parser) {
        let _ = super::opt_visibility(p);
    }
diff --git a/crates/parser/src/lib.rs b/crates/parser/src/lib.rs
index 811e740f9..9dfe63028 100644
--- a/crates/parser/src/lib.rs
+++ b/crates/parser/src/lib.rs
@@ -88,6 +88,7 @@ pub enum FragmentKind {
    Path,
    Expr,
    Statement,
+    StatementOptionalSemi,
    Type,
    Pattern,
    Item,
@@ -118,6 +119,7 @@ pub fn parse_fragment(
        FragmentKind::Visibility => grammar::fragments::opt_visibility,
        FragmentKind::MetaItem => grammar::fragments::meta_item,
        FragmentKind::Statement => grammar::fragments::stmt,
+        FragmentKind::StatementOptionalSemi => grammar::fragments::stmt_optional_semi,
        FragmentKind::Items => grammar::fragments::macro_items,
        FragmentKind::Statements => grammar::fragments::macro_stmts,
        FragmentKind::Attr => grammar::fragments::attr,
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 685a9fdf0..a80652e83 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -175,7 +175,7 @@ config_data! {
 #[derive(Debug, Clone)]
 pub struct Config {
-    pub client_caps: ClientCapsConfig,
+    pub caps: lsp_types::ClientCapabilities,
    pub publish_diagnostics: bool,
    pub diagnostics: DiagnosticsConfig,
@@ -286,26 +286,12 @@ pub struct RunnablesConfig {
    pub cargo_extra_args: Vec<String>,
 }
-#[derive(Debug, Clone, Default)]
-pub struct ClientCapsConfig {
-    pub location_link: bool,
-    pub line_folding_only: bool,
-    pub hierarchical_symbols: bool,
-    pub code_action_literals: bool,
-    pub work_done_progress: bool,
-    pub code_action_group: bool,
-    pub code_action_resolve: bool,
-    pub hover_actions: bool,
-    pub status_notification: bool,
-    pub signature_help_label_offsets: bool,
-}
 impl Config {
    pub fn new(root_path: AbsPathBuf) -> Self {
        // Defaults here don't matter, we'll immediately re-write them with
        // ConfigData.
        let mut res = Config {
-            client_caps: ClientCapsConfig::default(),
+            caps: lsp_types::ClientCapabilities::default(),
            publish_diagnostics: false,
            diagnostics: DiagnosticsConfig::default(),
@@ -505,38 +491,11 @@ impl Config {
    }
    pub fn update_caps(&mut self, caps: &ClientCapabilities) {
+        self.caps = caps.clone();
        if let Some(doc_caps) = caps.text_document.as_ref() {
            if let Some(value) = doc_caps.hover.as_ref().and_then(|it| it.content_format.as_ref()) {
                self.hover.markdown = value.contains(&MarkupKind::Markdown)
            }
-            if let Some(value) = doc_caps.definition.as_ref().and_then(|it| it.link_support) {
-                self.client_caps.location_link = value;
-            }
-            if let Some(value) = doc_caps.folding_range.as_ref().and_then(|it| it.line_folding_only)
-            {
-                self.client_caps.line_folding_only = value
-            }
-            if let Some(value) = doc_caps
-                .document_symbol
-                .as_ref()
-                .and_then(|it| it.hierarchical_document_symbol_support)
-            {
-                self.client_caps.hierarchical_symbols = value
-            }
-            if let Some(value) =
-                doc_caps.code_action.as_ref().map(|it| it.code_action_literal_support.is_some())
-            {
-                self.client_caps.code_action_literals = value;
-            }
-            if let Some(value) = doc_caps
-                .signature_help
-                .as_ref()
-                .and_then(|it| it.signature_information.as_ref())
-                .and_then(|it| it.parameter_information.as_ref())
-                .and_then(|it| it.label_offset_support)
-            {
-                self.client_caps.signature_help_label_offsets = value;
-            }
            self.completion.allow_snippets(false);
            self.completion.active_resolve_capabilities =
@@ -548,20 +507,6 @@ impl Config {
                    }
                }
            }
-            if let Some(code_action) = &doc_caps.code_action {
-                if let Some(resolve_support) = &code_action.resolve_support {
-                    if resolve_support.properties.iter().any(|it| it == "edit") {
-                        self.client_caps.code_action_resolve = true;
-                    }
-                }
-            }
-        }
-        if let Some(window_caps) = caps.window.as_ref() {
-            if let Some(value) = window_caps.work_done_progress {
-                self.client_caps.work_done_progress = value;
-            }
        }
        self.assist.allow_snippets(false);
@@ -571,10 +516,6 @@ impl Config {
            let snippet_text_edit = get_bool("snippetTextEdit");
            self.assist.allow_snippets(snippet_text_edit);
-            self.client_caps.code_action_group = get_bool("codeActionGroup");
-            self.client_caps.hover_actions = get_bool("hoverActions");
-            self.client_caps.status_notification = get_bool("statusNotification");
        }
        if let Some(workspace_caps) = caps.workspace.as_ref() {
@@ -597,6 +538,95 @@ impl Config {
    }
 }
+macro_rules! try_ {
+    ($expr:expr) => {
+        || -> _ { Some($expr) }()
+    };
+}
+macro_rules! try_or {
+    ($expr:expr, $or:expr) => {
+        try_!($expr).unwrap_or($or)
+    };
+}
+impl Config {
+    pub fn location_link(&self) -> bool {
+        try_or!(self.caps.text_document.as_ref()?.definition?.link_support?, false)
+    }
+    pub fn line_folding_only(&self) -> bool {
+        try_or!(self.caps.text_document.as_ref()?.folding_range.as_ref()?.line_folding_only?, false)
+    }
+    pub fn hierarchical_symbols(&self) -> bool {
+        try_or!(
+            self.caps
+                .text_document
+                .as_ref()?
+                .document_symbol
+                .as_ref()?
+                .hierarchical_document_symbol_support?,
+            false
+        )
+    }
+    pub fn code_action_literals(&self) -> bool {
+        try_!(self
+            .caps
+            .text_document
+            .as_ref()?
+            .code_action
+            .as_ref()?
+            .code_action_literal_support
+            .as_ref()?)
+        .is_some()
+    }
+    pub fn work_done_progress(&self) -> bool {
+        try_or!(self.caps.window.as_ref()?.work_done_progress?, false)
+    }
+    pub fn code_action_resolve(&self) -> bool {
+        try_or!(
+            self.caps
+                .text_document
+                .as_ref()?
+                .code_action
+                .as_ref()?
+                .resolve_support
+                .as_ref()?
+                .properties
+                .as_slice(),
+            &[]
+        )
+        .iter()
+        .any(|it| it == "edit")
+    }
+    pub fn signature_help_label_offsets(&self) -> bool {
+        try_or!(
+            self.caps
+                .text_document
+                .as_ref()?
+                .signature_help
+                .as_ref()?
+                .signature_information
+                .as_ref()?
+                .parameter_information
+                .as_ref()?
+                .label_offset_support?,
+            false
+        )
+    }
+    fn experimental(&self, index: &'static str) -> bool {
+        try_or!(self.caps.experimental.as_ref()?.get(index)?.as_bool()?, false)
+    }
+    pub fn code_action_group(&self) -> bool {
+        self.experimental("codeActionGroup")
+    }
+    pub fn hover_actions(&self) -> bool {
+        self.experimental("hoverActions")
+    }
+    pub fn status_notification(&self) -> bool {
+        self.experimental("statusNotification")
+    }
+}
 #[derive(Deserialize)]
 #[serde(untagged)]
 enum ManifestOrProjectJson {
@@ -777,9 +807,8 @@ fn manual(fields: &[(&'static str, &'static str, &[&str], &str)]) -> String {
    fields
        .iter()
        .map(|(field, _ty, doc, default)| {
-            let name = field.replace("_", ".");
+            let name = format!("rust-analyzer.{}", field.replace("_", "."));
-            let name = format!("rust-analyzer.{} (default: `{}`)", name, default);
+            format!("[[{}]]{} (default: `{}`)::\n{}\n", name, name, default, doc.join(" "))
-            format!("{}::\n{}\n", name, doc.join(" "))
        })
        .collect::<String>()
 }
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 3e49904c3..071b34cda 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -321,7 +321,7 @@ pub(crate) fn handle_document_symbol(
        acc
    };
-    let res = if snap.config.client_caps.hierarchical_symbols {
+    let res = if snap.config.hierarchical_symbols() {
        document_symbols.into()
    } else {
        let url = to_proto::url(&snap, file_id);
@@ -728,7 +728,7 @@ pub(crate) fn handle_folding_range(
    let folds = snap.analysis.folding_ranges(file_id)?;
    let text = snap.analysis.file_text(file_id)?;
    let line_index = snap.analysis.file_line_index(file_id)?;
-    let line_folding_only = snap.config.client_caps.line_folding_only;
+    let line_folding_only = snap.config.line_folding_only();
    let res = folds
        .into_iter()
        .map(|it| to_proto::folding_range(&*text, &line_index, line_folding_only, it))
@@ -747,11 +747,8 @@ pub(crate) fn handle_signature_help(
        None => return Ok(None),
    };
    let concise = !snap.config.call_info_full;
-    let res = to_proto::signature_help(
+    let res =
-        call_info,
+        to_proto::signature_help(call_info, concise, snap.config.signature_help_label_offsets());
-        concise,
-        snap.config.client_caps.signature_help_label_offsets,
-    );
    Ok(Some(res))
 }
@@ -941,7 +938,7 @@ pub(crate) fn handle_code_action(
    // We intentionally don't support command-based actions, as those either
    // requires custom client-code anyway, or requires server-initiated edits.
    // Server initiated edits break causality, so we avoid those as well.
-    if !snap.config.client_caps.code_action_literals {
+    if !snap.config.code_action_literals() {
        return Ok(None);
    }
@@ -971,7 +968,7 @@ pub(crate) fn handle_code_action(
        add_quick_fixes(&snap, frange, &line_index, &mut res)?;
    }
-    if snap.config.client_caps.code_action_resolve {
+    if snap.config.code_action_resolve() {
        for (index, assist) in
            snap.analysis.assists(&assists_config, false, frange)?.into_iter().enumerate()
        {
@@ -1554,7 +1551,7 @@ fn debug_single_command(runnable: &lsp_ext::Runnable) -> Command {
 }
 fn goto_location_command(snap: &GlobalStateSnapshot, nav: &NavigationTarget) -> Option<Command> {
-    let value = if snap.config.client_caps.location_link {
+    let value = if snap.config.location_link() {
        let link = to_proto::location_link(snap, None, nav.clone()).ok()?;
        to_value(link).ok()?
    } else {
@@ -1653,14 +1650,14 @@ fn prepare_hover_actions(
    file_id: FileId,
    actions: &[HoverAction],
 ) -> Vec<lsp_ext::CommandLinkGroup> {
-    if snap.config.hover.none() || !snap.config.client_caps.hover_actions {
+    if snap.config.hover.none() || !snap.config.hover_actions() {
        return Vec::new();
    }
    actions
        .iter()
        .filter_map(|it| match it {
-            HoverAction::Implementaion(position) => show_impl_command_link(snap, position),
+            HoverAction::Implementation(position) => show_impl_command_link(snap, position),
            HoverAction::Runnable(r) => runnable_action_links(snap, file_id, r.clone()),
            HoverAction::GoToType(targets) => goto_type_action_links(snap, targets),
        })
diff --git a/crates/rust-analyzer/src/lsp_utils.rs b/crates/rust-analyzer/src/lsp_utils.rs
index 60c12e4e2..40de56dad 100644
--- a/crates/rust-analyzer/src/lsp_utils.rs
+++ b/crates/rust-analyzer/src/lsp_utils.rs
@@ -46,7 +46,7 @@ impl GlobalState {
        message: Option<String>,
        fraction: Option<f64>,
    ) {
-        if !self.config.client_caps.work_done_progress {
+        if !self.config.work_done_progress() {
            return;
        }
        let percentage = fraction.map(|f| {
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index 79e39e3a5..ce5cedeb3 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -79,7 +79,7 @@ impl GlobalState {
    }
    pub(crate) fn transition(&mut self, new_status: Status) {
        self.status = new_status;
-        if self.config.client_caps.status_notification {
+        if self.config.status_notification() {
            let lsp_status = match new_status {
                Status::Loading => lsp_ext::Status::Loading,
                Status::Ready => lsp_ext::Status::Ready,
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 999b18351..e0413ec06 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -605,7 +605,7 @@ pub(crate) fn goto_definition_response(
    src: Option<FileRange>,
    targets: Vec<NavigationTarget>,
 ) -> Result<lsp_types::GotoDefinitionResponse> {
-    if snap.config.client_caps.location_link {
+    if snap.config.location_link() {
        let links = targets
            .into_iter()
            .map(|nav| location_link(snap, src, nav))
@@ -785,7 +785,7 @@ pub(crate) fn unresolved_code_action(
    assert!(assist.source_change.is_none());
    let res = lsp_ext::CodeAction {
        title: assist.label.to_string(),
-        group: assist.group.filter(|_| snap.config.client_caps.code_action_group).map(|gr| gr.0),
+        group: assist.group.filter(|_| snap.config.code_action_group()).map(|gr| gr.0),
        kind: Some(code_action_kind(assist.id.1)),
        edit: None,
        is_preferred: None,
@@ -805,7 +805,7 @@ pub(crate) fn resolved_code_action(
    let res = lsp_ext::CodeAction {
        edit: Some(snippet_workspace_edit(snap, change)?),
        title: assist.label.to_string(),
-        group: assist.group.filter(|_| snap.config.client_caps.code_action_group).map(|gr| gr.0),
+        group: assist.group.filter(|_| snap.config.code_action_group()).map(|gr| gr.0),
        kind: Some(code_action_kind(assist.id.1)),
        is_preferred: None,
        data: None,
diff --git a/crates/rust-analyzer/tests/rust-analyzer/support.rs b/crates/rust-analyzer/tests/rust-analyzer/support.rs
index 456125789..aac7dbcce 100644
--- a/crates/rust-analyzer/tests/rust-analyzer/support.rs
+++ b/crates/rust-analyzer/tests/rust-analyzer/support.rs
@@ -14,7 +14,7 @@ use lsp_types::{
 use lsp_types::{ProgressParams, ProgressParamsValue};
 use project_model::{CargoConfig, ProjectManifest};
 use rust_analyzer::{
-    config::{ClientCapsConfig, Config, FilesConfig, FilesWatcher, LinkedProject},
+    config::{Config, FilesConfig, FilesWatcher, LinkedProject},
    main_loop,
 };
 use serde::Serialize;
@@ -84,10 +84,24 @@ impl<'a> Project<'a> {
            .collect::<Vec<_>>();
        let mut config = Config {
-            client_caps: ClientCapsConfig {
+            caps: lsp_types::ClientCapabilities {
-                location_link: true,
+                text_document: Some(lsp_types::TextDocumentClientCapabilities {
-                code_action_literals: true,
+                    definition: Some(lsp_types::GotoCapability {
-                work_done_progress: true,
+                        link_support: Some(true),
+                        ..Default::default()
+                    }),
+                    code_action: Some(lsp_types::CodeActionClientCapabilities {
+                        code_action_literal_support: Some(
+                            lsp_types::CodeActionLiteralSupport::default(),
+                        ),
+                        ..Default::default()
+                    }),
+                    ..Default::default()
+                }),
+                window: Some(lsp_types::WindowClientCapabilities {
+                    work_done_progress: Some(true),
+                    ..Default::default()
+                }),
                ..Default::default()
            },
            cargo: CargoConfig { no_sysroot: !self.with_sysroot, ..Default::default() },
diff --git a/crates/ssr/src/parsing.rs b/crates/ssr/src/parsing.rs
index f3b084baf..3d5e4feb7 100644
--- a/crates/ssr/src/parsing.rs
+++ b/crates/ssr/src/parsing.rs
@@ -73,11 +73,18 @@ impl ParsedRule {
            placeholders_by_stand_in: pattern.placeholders_by_stand_in(),
            rules: Vec::new(),
        };
-        builder.try_add(ast::Expr::parse(&raw_pattern), raw_template.map(ast::Expr::parse));
+        let raw_template_stmt = raw_template.map(ast::Stmt::parse);
+        if let raw_template_expr @ Some(Ok(_)) = raw_template.map(ast::Expr::parse) {
+            builder.try_add(ast::Expr::parse(&raw_pattern), raw_template_expr);
+        } else {
+            builder.try_add(ast::Expr::parse(&raw_pattern), raw_template_stmt.clone());
+        }
        builder.try_add(ast::Type::parse(&raw_pattern), raw_template.map(ast::Type::parse));
        builder.try_add(ast::Item::parse(&raw_pattern), raw_template.map(ast::Item::parse));
        builder.try_add(ast::Path::parse(&raw_pattern), raw_template.map(ast::Path::parse));
        builder.try_add(ast::Pat::parse(&raw_pattern), raw_template.map(ast::Pat::parse));
+        builder.try_add(ast::Stmt::parse(&raw_pattern), raw_template_stmt);
        builder.build()
    }
 }
@@ -88,7 +95,11 @@ struct RuleBuilder {
 }
 impl RuleBuilder {
-    fn try_add<T: AstNode>(&mut self, pattern: Result<T, ()>, template: Option<Result<T, ()>>) {
+    fn try_add<T: AstNode, T2: AstNode>(
+        &mut self,
+        pattern: Result<T, ()>,
+        template: Option<Result<T2, ()>>,
+    ) {
        match (pattern, template) {
            (Ok(pattern), Some(Ok(template))) => self.rules.push(ParsedRule {
                placeholders_by_stand_in: self.placeholders_by_stand_in.clone(),
diff --git a/crates/ssr/src/tests.rs b/crates/ssr/src/tests.rs
index 63131f6ca..db9cb8ca1 100644
--- a/crates/ssr/src/tests.rs
+++ b/crates/ssr/src/tests.rs
@@ -160,6 +160,97 @@ fn assert_match_failure_reason(pattern: &str, code: &str, snippet: &str, expecte
 }
 #[test]
+fn ssr_let_stmt_in_macro_match() {
+    assert_matches(
+        "let a = 0",
+        r#"
+            macro_rules! m1 { ($a:stmt) => {$a}; }
+            fn f() {m1!{ let a = 0 };}"#,
+        // FIXME: Whitespace is not part of the matched block
+        &["leta=0"],
+    );
+}
+#[test]
+fn ssr_let_stmt_in_fn_match() {
+    assert_matches("let $a = 10;", "fn main() { let x = 10; x }", &["let x = 10;"]);
+    assert_matches("let $a = $b;", "fn main() { let x = 10; x }", &["let x = 10;"]);
+}
+#[test]
+fn ssr_block_expr_match() {
+    assert_matches("{ let $a = $b; }", "fn main() { let x = 10; }", &["{ let x = 10; }"]);
+    assert_matches("{ let $a = $b; $c }", "fn main() { let x = 10; x }", &["{ let x = 10; x }"]);
+}
+#[test]
+fn ssr_let_stmt_replace() {
+    // Pattern and template with trailing semicolon
+    assert_ssr_transform(
+        "let $a = $b; ==>> let $a = 11;",
+        "fn main() { let x = 10; x }",
+        expect![["fn main() { let x = 11; x }"]],
+    );
+}
+#[test]
+fn ssr_let_stmt_replace_expr() {
+    // Trailing semicolon should be dropped from the new expression
+    assert_ssr_transform(
+        "let $a = $b; ==>> $b",
+        "fn main() { let x = 10; }",
+        expect![["fn main() { 10 }"]],
+    );
+}
+#[test]
+fn ssr_blockexpr_replace_stmt_with_stmt() {
+    assert_ssr_transform(
+        "if $a() {$b;} ==>> $b;",
+        "{
+    if foo() {
+        bar();
+    }
+    Ok(())
+}",
+        expect![[r#"{
+    bar();
+    Ok(())
+}"#]],
+    );
+}
+#[test]
+fn ssr_blockexpr_match_trailing_expr() {
+    assert_matches(
+        "if $a() {$b;}",
+        "{
+    if foo() {
+        bar();
+    }
+}",
+        &["if foo() {
+        bar();
+    }"],
+    );
+}
+#[test]
+fn ssr_blockexpr_replace_trailing_expr_with_stmt() {
+    assert_ssr_transform(
+        "if $a() {$b;} ==>> $b;",
+        "{
+    if foo() {
+        bar();
+    }
+}",
+        expect![["{
+    bar();
+}"]],
+    );
+}
+#[test]
 fn ssr_function_to_method() {
    assert_ssr_transform(
        "my_function($a, $b) ==>> ($a).my_method($b)",
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index 181077944..cfeaed9e6 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -13,7 +13,7 @@ doctest = false
 [dependencies]
 itertools = "0.10.0"
 rowan = "0.10.0"
-rustc_lexer = { version = "695.0.0", package = "rustc-ap-rustc_lexer" }
+rustc_lexer = { version = "697.0.0", package = "rustc-ap-rustc_lexer" }
 rustc-hash = "1.1.0"
 arrayvec = "0.5.1"
 once_cell = "1.3.1"
diff --git a/crates/syntax/src/ast/generated/nodes.rs b/crates/syntax/src/ast/generated/nodes.rs
index c5b80bffe..92ed2ee9d 100644
--- a/crates/syntax/src/ast/generated/nodes.rs
+++ b/crates/syntax/src/ast/generated/nodes.rs
@@ -484,7 +484,7 @@ impl ast::AttrsOwner for BlockExpr {}
 impl BlockExpr {
    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
    pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
-    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn tail_expr(&self) -> Option<Expr> { support::child(&self.syntax) }
    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
diff --git a/crates/syntax/src/lib.rs b/crates/syntax/src/lib.rs
index 4d272f367..ea7482bb1 100644
--- a/crates/syntax/src/lib.rs
+++ b/crates/syntax/src/lib.rs
@@ -212,6 +212,13 @@ impl ast::Attr {
    }
 }
+impl ast::Stmt {
+    /// Returns `text`, parsed as statement, but only if it has no errors.
+    pub fn parse(text: &str) -> Result<Self, ()> {
+        parsing::parse_text_fragment(text, parser::FragmentKind::StatementOptionalSemi)
+    }
+}
 /// Matches a `SyntaxNode` against an `ast` type.
 ///
 /// # Example:
@@ -283,7 +290,7 @@ fn api_walkthrough() {
    // Let's get the `1 + 1` expression!
    let body: ast::BlockExpr = func.body().unwrap();
-    let expr: ast::Expr = body.expr().unwrap();
+    let expr: ast::Expr = body.tail_expr().unwrap();
    // Enums are used to group related ast nodes together, and can be used for
    // matching. However, because there are no public fields, it's possible to
diff --git a/crates/syntax/src/tests.rs b/crates/syntax/src/tests.rs
index 8c217dfe0..9d3433c9d 100644
--- a/crates/syntax/src/tests.rs
+++ b/crates/syntax/src/tests.rs
@@ -103,6 +103,15 @@ fn type_parser_tests() {
 }
 #[test]
+fn stmt_parser_tests() {
+    fragment_parser_dir_test(
+        &["parser/fragments/stmt/ok"],
+        &["parser/fragments/stmt/err"],
+        crate::ast::Stmt::parse,
+    );
+}
+#[test]
 fn parser_fuzz_tests() {
    for (_, text) in collect_rust_files(&test_data_dir(), &["parser/fuzz-failures"]) {
        fuzz::check_parser(&text)
diff --git a/crates/syntax/test_data/parser/fragments/stmt/err/0000_attr.rast b/crates/syntax/test_data/parser/fragments/stmt/err/0000_attr.rast
new file mode 100644
index 000000000..5df7507e2
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/err/0000_attr.rast
@@ -0,0 +1 @@
+ERROR
diff --git a/crates/syntax/test_data/parser/fragments/stmt/err/0000_attr.rs b/crates/syntax/test_data/parser/fragments/stmt/err/0000_attr.rs
new file mode 100644
index 000000000..988df0705
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/err/0000_attr.rs
@@ -0,0 +1 @@
+#[foo]
diff --git a/crates/syntax/test_data/parser/fragments/stmt/err/0000_multiple_stmts.rast b/crates/syntax/test_data/parser/fragments/stmt/err/0000_multiple_stmts.rast
new file mode 100644
index 000000000..5df7507e2
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/err/0000_multiple_stmts.rast
@@ -0,0 +1 @@
+ERROR
diff --git a/crates/syntax/test_data/parser/fragments/stmt/err/0000_multiple_stmts.rs b/crates/syntax/test_data/parser/fragments/stmt/err/0000_multiple_stmts.rs
new file mode 100644
index 000000000..7e3b2fd49
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/err/0000_multiple_stmts.rs
@@ -0,0 +1 @@
+a(); b(); c()
diff --git a/crates/syntax/test_data/parser/fragments/stmt/err/0000_open_parenthesis.rast b/crates/syntax/test_data/parser/fragments/stmt/err/0000_open_parenthesis.rast
new file mode 100644
index 000000000..5df7507e2
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/err/0000_open_parenthesis.rast
@@ -0,0 +1 @@
+ERROR
diff --git a/crates/syntax/test_data/parser/fragments/stmt/err/0000_open_parenthesis.rs b/crates/syntax/test_data/parser/fragments/stmt/err/0000_open_parenthesis.rs
new file mode 100644
index 000000000..2d06f3766
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/err/0000_open_parenthesis.rs
@@ -0,0 +1 @@
+(
diff --git a/crates/syntax/test_data/parser/fragments/stmt/err/0000_semicolon.rast b/crates/syntax/test_data/parser/fragments/stmt/err/0000_semicolon.rast
new file mode 100644
index 000000000..5df7507e2
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/err/0000_semicolon.rast
@@ -0,0 +1 @@
+ERROR
diff --git a/crates/syntax/test_data/parser/fragments/stmt/err/0000_semicolon.rs b/crates/syntax/test_data/parser/fragments/stmt/err/0000_semicolon.rs
new file mode 100644
index 000000000..092bc2b04
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/err/0000_semicolon.rs
@@ -0,0 +1 @@
+;
diff --git a/crates/syntax/test_data/parser/fragments/stmt/err/0000_unterminated_expr.rast b/crates/syntax/test_data/parser/fragments/stmt/err/0000_unterminated_expr.rast
new file mode 100644
index 000000000..5df7507e2
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/err/0000_unterminated_expr.rast
@@ -0,0 +1 @@
+ERROR
diff --git a/crates/syntax/test_data/parser/fragments/stmt/err/0000_unterminated_expr.rs b/crates/syntax/test_data/parser/fragments/stmt/err/0000_unterminated_expr.rs
new file mode 100644
index 000000000..ca49acb07
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/err/0000_unterminated_expr.rs
@@ -0,0 +1 @@
+1 +
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_expr.rast b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_expr.rast
new file mode 100644
index 000000000..274fdf16d
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_expr.rast
@@ -0,0 +1,9 @@
+[email protected]
+  [email protected]
+    [email protected]
+      [email protected] "1"
+    [email protected] " "
+    [email protected] "+"
+    [email protected] " "
+    [email protected]
+      [email protected] "1"
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_expr.rs b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_expr.rs
new file mode 100644
index 000000000..8d2f0971e
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_expr.rs
@@ -0,0 +1 @@
+1 + 1
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_expr_block.rast b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_expr_block.rast
new file mode 100644
index 000000000..6c946091f
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_expr_block.rast
@@ -0,0 +1,69 @@
+[email protected]
+  [email protected]
+    [email protected] "{"
+    [email protected] "\n    "
+    [email protected]
+      [email protected] "let"
+      [email protected] " "
+      [email protected]
+        [email protected]
+          [email protected] "x"
+      [email protected] " "
+      [email protected] "="
+      [email protected] " "
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected] "foo"
+        [email protected]
+          [email protected] "("
+          [email protected] ")"
+      [email protected] ";"
+    [email protected] "\n    "
+    [email protected]
+      [email protected] "let"
+      [email protected] " "
+      [email protected]
+        [email protected]
+          [email protected] "y"
+      [email protected] " "
+      [email protected] "="
+      [email protected] " "
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected] "bar"
+        [email protected]
+          [email protected] "("
+          [email protected] ")"
+      [email protected] ";"
+    [email protected] "\n    "
+    [email protected]
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected]
+              [email protected] "Ok"
+      [email protected]
+        [email protected] "("
+        [email protected]
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected] "x"
+          [email protected] " "
+          [email protected] "+"
+          [email protected] " "
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected] "y"
+        [email protected] ")"
+    [email protected] "\n"
+    [email protected] "}"
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_expr_block.rs b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_expr_block.rs
new file mode 100644
index 000000000..ffa5c1e66
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_expr_block.rs
@@ -0,0 +1,5 @@
+{
+    let x = foo();
+    let y = bar();
+    Ok(x + y)
+}
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_fn_call.rast b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_fn_call.rast
new file mode 100644
index 000000000..8c186da93
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_fn_call.rast
@@ -0,0 +1,11 @@
+[email protected]
+  [email protected]
+    [email protected]
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected] "foo"
+    [email protected]
+      [email protected] "("
+      [email protected] ")"
+  [email protected] ";"
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_fn_call.rs b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_fn_call.rs
new file mode 100644
index 000000000..a280f9a5c
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_fn_call.rs
@@ -0,0 +1 @@
+foo();
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_let_stmt.rast b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_let_stmt.rast
new file mode 100644
index 000000000..8ab38da21
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_let_stmt.rast
@@ -0,0 +1,12 @@
+[email protected]
+  [email protected] "let"
+  [email protected] " "
+  [email protected]
+    [email protected]
+      [email protected] "x"
+  [email protected] " "
+  [email protected] "="
+  [email protected] " "
+  [email protected]
+    [email protected] "10"
+  [email protected] ";"
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_let_stmt.rs b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_let_stmt.rs
new file mode 100644
index 000000000..de8a7f1fc
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_let_stmt.rs
@@ -0,0 +1 @@
+let x = 10;
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_macro_let_stmt.rast b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_macro_let_stmt.rast
new file mode 100644
index 000000000..81d6df29a
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_macro_let_stmt.rast
@@ -0,0 +1,21 @@
+[email protected]
+  [email protected]
+    [email protected]
+      [email protected]
+        [email protected]
+          [email protected] "m1"
+    [email protected] "!"
+    [email protected]
+      [email protected] "{"
+      [email protected] " "
+      [email protected] "let"
+      [email protected] " "
+      [email protected] "a"
+      [email protected] " "
+      [email protected] "="
+      [email protected] " "
+      [email protected] "0"
+      [email protected] ";"
+      [email protected] " "
+      [email protected] "}"
+  [email protected] ";"
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_macro_let_stmt.rs b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_macro_let_stmt.rs
new file mode 100644
index 000000000..075f30159
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_macro_let_stmt.rs
@@ -0,0 +1 @@
+m1!{ let a = 0; };
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_macro_unterminated_let_stmt.rast b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_macro_unterminated_let_stmt.rast
new file mode 100644
index 000000000..81d6df29a
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_macro_unterminated_let_stmt.rast
@@ -0,0 +1,21 @@
+[email protected]
+  [email protected]
+    [email protected]
+      [email protected]
+        [email protected]
+          [email protected] "m1"
+    [email protected] "!"
+    [email protected]
+      [email protected] "{"
+      [email protected] " "
+      [email protected] "let"
+      [email protected] " "
+      [email protected] "a"
+      [email protected] " "
+      [email protected] "="
+      [email protected] " "
+      [email protected] "0"
+      [email protected] ";"
+      [email protected] " "
+      [email protected] "}"
+  [email protected] ";"
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_macro_unterminated_let_stmt.rs b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_macro_unterminated_let_stmt.rs
new file mode 100644
index 000000000..075f30159
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_macro_unterminated_let_stmt.rs
@@ -0,0 +1 @@
+m1!{ let a = 0; };
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_struct_item.rast b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_struct_item.rast
new file mode 100644
index 000000000..64c5d2969
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_struct_item.rast
@@ -0,0 +1,22 @@
+[email protected]
+  [email protected] "struct"
+  [email protected] " "
+  [email protected]
+    [email protected] "Foo"
+  [email protected] " "
+  [email protected]
+    [email protected] "{"
+    [email protected] "\n    "
+    [email protected]
+      [email protected]
+        [email protected] "bar"
+      [email protected] ":"
+      [email protected] " "
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected]
+              [email protected] "u32"
+    [email protected] ","
+    [email protected] "\n"
+    [email protected] "}"
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_struct_item.rs b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_struct_item.rs
new file mode 100644
index 000000000..e5473e3ac
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_struct_item.rs
@@ -0,0 +1,3 @@
+struct Foo {
+    bar: u32,
+}
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_unterminated_fn_call.rast b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_unterminated_fn_call.rast
new file mode 100644
index 000000000..9089906bc
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_unterminated_fn_call.rast
@@ -0,0 +1,10 @@
+[email protected]
+  [email protected]
+    [email protected]
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected] "foo"
+    [email protected]
+      [email protected] "("
+      [email protected] ")"
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_unterminated_fn_call.rs b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_unterminated_fn_call.rs
new file mode 100644
index 000000000..eb28ef440
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_unterminated_fn_call.rs
@@ -0,0 +1 @@
+foo()
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_unterminated_let_stmt.rast b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_unterminated_let_stmt.rast
new file mode 100644
index 000000000..37663671f
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_unterminated_let_stmt.rast
@@ -0,0 +1,11 @@
+[email protected]
+  [email protected] "let"
+  [email protected] " "
+  [email protected]
+    [email protected]
+      [email protected] "x"
+  [email protected] " "
+  [email protected] "="
+  [email protected] " "
+  [email protected]
+    [email protected] "10"
diff --git a/crates/syntax/test_data/parser/fragments/stmt/ok/0000_unterminated_let_stmt.rs b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_unterminated_let_stmt.rs
new file mode 100644
index 000000000..78364b2a9
--- /dev/null
+++ b/crates/syntax/test_data/parser/fragments/stmt/ok/0000_unterminated_let_stmt.rs
@@ -0,0 +1 @@
+let x = 10
diff --git a/crates/tt/src/buffer.rs b/crates/tt/src/buffer.rs
index 02c771f70..3606c887d 100644
--- a/crates/tt/src/buffer.rs
+++ b/crates/tt/src/buffer.rs
@@ -1,6 +1,6 @@
 //! FIXME: write short doc here
-use crate::{Subtree, TokenTree};
+use crate::{Leaf, Subtree, TokenTree};
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 struct EntryId(usize);
@@ -13,7 +13,7 @@ struct EntryPtr(EntryId, usize);
 #[derive(Debug)]
 enum Entry<'t> {
    // Mimicking types from proc-macro.
-    Subtree(&'t TokenTree, EntryId),
+    Subtree(Option<&'t TokenTree>, &'t Subtree, EntryId),
    Leaf(&'t TokenTree),
    // End entries contain a pointer to the entry from the containing
    // token tree, or None if this is the outermost level.
@@ -27,37 +27,64 @@ pub struct TokenBuffer<'t> {
    buffers: Vec<Box<[Entry<'t>]>>,
 }
-impl<'t> TokenBuffer<'t> {
+trait TokenList<'a> {
-    pub fn new(tokens: &'t [TokenTree]) -> TokenBuffer<'t> {
+    fn entries(&self) -> (Vec<(usize, (&'a Subtree, Option<&'a TokenTree>))>, Vec<Entry<'a>>);
-        let mut buffers = vec![];
+}
-        let idx = TokenBuffer::new_inner(tokens, &mut buffers, None);
-        assert_eq!(idx, 0);
-        TokenBuffer { buffers }
-    }
-    fn new_inner(
+impl<'a> TokenList<'a> for &'a [TokenTree] {
-        tokens: &'t [TokenTree],
+    fn entries(&self) -> (Vec<(usize, (&'a Subtree, Option<&'a TokenTree>))>, Vec<Entry<'a>>) {
-        buffers: &mut Vec<Box<[Entry<'t>]>>,
-        next: Option<EntryPtr>,
-    ) -> usize {
        // Must contain everything in tokens and then the Entry::End
-        let start_capacity = tokens.len() + 1;
+        let start_capacity = self.len() + 1;
        let mut entries = Vec::with_capacity(start_capacity);
        let mut children = vec![];
+        for (idx, tt) in self.iter().enumerate() {
-        for (idx, tt) in tokens.iter().enumerate() {
            match tt {
                TokenTree::Leaf(_) => {
                    entries.push(Entry::Leaf(tt));
                }
                TokenTree::Subtree(subtree) => {
                    entries.push(Entry::End(None));
-                    children.push((idx, (subtree, tt)));
+                    children.push((idx, (subtree, Some(tt))));
                }
            }
        }
+        (children, entries)
+    }
+}
+impl<'a> TokenList<'a> for &'a Subtree {
+    fn entries(&self) -> (Vec<(usize, (&'a Subtree, Option<&'a TokenTree>))>, Vec<Entry<'a>>) {
+        // Must contain everything in tokens and then the Entry::End
+        let mut entries = vec![];
+        let mut children = vec![];
+        entries.push(Entry::End(None));
+        children.push((0usize, (*self, None)));
+        (children, entries)
+    }
+}
+impl<'t> TokenBuffer<'t> {
+    pub fn from_tokens(tokens: &'t [TokenTree]) -> TokenBuffer<'t> {
+        Self::new(tokens)
+    }
+    pub fn from_subtree(subtree: &'t Subtree) -> TokenBuffer<'t> {
+        Self::new(subtree)
+    }
+    fn new<T: TokenList<'t>>(tokens: T) -> TokenBuffer<'t> {
+        let mut buffers = vec![];
+        let idx = TokenBuffer::new_inner(tokens, &mut buffers, None);
+        assert_eq!(idx, 0);
+        TokenBuffer { buffers }
+    }
+    fn new_inner<T: TokenList<'t>>(
+        tokens: T,
+        buffers: &mut Vec<Box<[Entry<'t>]>>,
+        next: Option<EntryPtr>,
+    ) -> usize {
+        let (children, mut entries) = tokens.entries();
        entries.push(Entry::End(next));
        let res = buffers.len();
@@ -65,11 +92,11 @@ impl<'t> TokenBuffer<'t> {
        for (child_idx, (subtree, tt)) in children {
            let idx = TokenBuffer::new_inner(
-                &subtree.token_trees,
+                subtree.token_trees.as_slice(),
                buffers,
                Some(EntryPtr(EntryId(res), child_idx + 1)),
            );
-            buffers[res].as_mut()[child_idx] = Entry::Subtree(tt, EntryId(idx));
+            buffers[res].as_mut()[child_idx] = Entry::Subtree(tt, subtree, EntryId(idx));
        }
        res
@@ -87,6 +114,24 @@ impl<'t> TokenBuffer<'t> {
    }
 }
+#[derive(Debug)]
+pub enum TokenTreeRef<'a> {
+    Subtree(&'a Subtree, Option<&'a TokenTree>),
+    Leaf(&'a Leaf, &'a TokenTree),
+}
+impl<'a> TokenTreeRef<'a> {
+    pub fn cloned(&self) -> TokenTree {
+        match &self {
+            TokenTreeRef::Subtree(subtree, tt) => match tt {
+                Some(it) => (*it).clone(),
+                None => (*subtree).clone().into(),
+            },
+            TokenTreeRef::Leaf(_, tt) => (*tt).clone(),
+        }
+    }
+}
 /// A safe version of `Cursor` from `syn` crate https://github.com/dtolnay/syn/blob/6533607f91686545cb034d2838beea338d9d0742/src/buffer.rs#L125
 #[derive(Copy, Clone, Debug)]
 pub struct Cursor<'a> {
@@ -114,12 +159,11 @@ impl<'a> Cursor<'a> {
        match self.entry() {
            Some(Entry::End(Some(ptr))) => {
                let idx = ptr.1;
-                if let Some(Entry::Subtree(TokenTree::Subtree(subtree), _)) =
+                if let Some(Entry::Subtree(_, subtree, _)) =
                    self.buffer.entry(&EntryPtr(ptr.0, idx - 1))
                {
                    return Some(subtree);
                }
                None
            }
            _ => None,
@@ -134,7 +178,7 @@ impl<'a> Cursor<'a> {
    /// a cursor into that subtree
    pub fn subtree(self) -> Option<Cursor<'a>> {
        match self.entry() {
-            Some(Entry::Subtree(_, entry_id)) => {
+            Some(Entry::Subtree(_, _, entry_id)) => {
                Some(Cursor::create(self.buffer, EntryPtr(*entry_id, 0)))
            }
            _ => None,
@@ -142,10 +186,13 @@ impl<'a> Cursor<'a> {
    }
    /// If the cursor is pointing at a `TokenTree`, returns it
-    pub fn token_tree(self) -> Option<&'a TokenTree> {
+    pub fn token_tree(self) -> Option<TokenTreeRef<'a>> {
        match self.entry() {
-            Some(Entry::Leaf(tt)) => Some(tt),
+            Some(Entry::Leaf(tt)) => match tt {
-            Some(Entry::Subtree(tt, _)) => Some(tt),
+                TokenTree::Leaf(leaf) => Some(TokenTreeRef::Leaf(leaf, *tt)),
+                TokenTree::Subtree(subtree) => Some(TokenTreeRef::Subtree(subtree, Some(tt))),
+            },
+            Some(Entry::Subtree(tt, subtree, _)) => Some(TokenTreeRef::Subtree(subtree, *tt)),
            Some(Entry::End(_)) => None,
            None => None,
        }
@@ -172,7 +219,7 @@ impl<'a> Cursor<'a> {
    /// a cursor into that subtree
    pub fn bump_subtree(self) -> Cursor<'a> {
        match self.entry() {
-            Some(Entry::Subtree(_, _)) => self.subtree().unwrap(),
+            Some(Entry::Subtree(_, _, _)) => self.subtree().unwrap(),
            _ => self.bump(),
        }
    }