82 files changed, 1745 insertions, 694 deletions
diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index 889ada401..ece1fd364 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -15,8 +15,8 @@ env:
  RUSTUP_MAX_RETRIES: 10
 jobs:
-  dist-windows:
+  dist-x86_64-pc-windows-msvc:
-    name: dist (Windows)
+    name: dist (x86_64-pc-windows-msvc)
    runs-on: windows-latest
    env:
      RA_TARGET: x86_64-pc-windows-msvc
@@ -45,11 +45,41 @@ jobs:
    - name: Upload artifacts
      uses: actions/upload-artifact@v1
      with:
-        name: dist-windows-latest
+        name: dist-x86_64-pc-windows-msvc
        path: ./dist
-  dist-ubuntu:
+  dist-aarch64-pc-windows-msvc:
-    name: dist (Ubuntu 16.04)
+    name: dist (aarch64-pc-windows-msvc)
+    runs-on: windows-latest
+    env:
+      RA_TARGET: aarch64-pc-windows-msvc
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+    - name: Rename existing rust toolchain
+      run: Rename-Item C:\Users\runneradmin\.rustup\toolchains\stable-x86_64-pc-windows-msvc C:\Users\runneradmin\.rustup\toolchains\stable-x86_64-pc-windows-msvc.old
+    - name: Install Rust toolchain
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        target: aarch64-pc-windows-msvc
+        profile: minimal
+        override: true
+    - name: Dist
+      run: cargo xtask dist
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v1
+      with:
+        name: dist-aarch64-pc-windows-msvc
+        path: ./dist
+  dist-x86_64-unknown-linux-gnu:
+    name: dist (x86_64-unknown-linux-gnu)
    runs-on: ubuntu-16.04
    env:
      RA_TARGET: x86_64-unknown-linux-gnu
@@ -85,11 +115,11 @@ jobs:
    - name: Upload artifacts
      uses: actions/upload-artifact@v1
      with:
-        name: dist-ubuntu-16.04
+        name: dist-x86_64-unknown-linux-gnu
        path: ./dist
-  dist-macos-latest:
+  dist-x86_64-apple-darwin:
-    name: dist (MacOS latest)
+    name: dist (x86_64-apple-darwin)
    runs-on: macos-latest
    env:
      RA_TARGET: x86_64-apple-darwin
@@ -111,12 +141,12 @@ jobs:
    - name: Upload artifacts
      uses: actions/upload-artifact@v1
      with:
-        name: dist-macos-latest
+        name: dist-x86_64-apple-darwin
        path: ./dist
-  dist-macos-11:
+  dist-aarch64-apple-darwin:
-    name: dist (MacOS 11.0)
+    name: dist (aarch64-apple-darwin)
-    runs-on: macos-11.0
+    runs-on: macos-latest
    env:
      RA_TARGET: aarch64-apple-darwin
@@ -133,18 +163,18 @@ jobs:
        override: true
    - name: Dist
-      run: cargo xtask dist
+      run: SDKROOT=$(xcrun -sdk macosx11.0 --show-sdk-path) MACOSX_DEPLOYMENT_TARGET=$(xcrun -sdk macosx11.0 --show-sdk-platform-version) cargo xtask dist
    - name: Upload artifacts
      uses: actions/upload-artifact@v1
      with:
-        name: dist-macos-11.0
+        name: dist-aarch64-apple-darwin
        path: ./dist
  publish:
    name: publish
    runs-on: ubuntu-16.04
-    needs: ['dist-windows', 'dist-ubuntu', 'dist-macos-latest', 'dist-macos-11']
+    needs: ['dist-x86_64-pc-windows-msvc', 'dist-aarch64-pc-windows-msvc', 'dist-x86_64-unknown-linux-gnu', 'dist-x86_64-apple-darwin', 'dist-aarch64-apple-darwin']
    steps:
    - name: Install Nodejs
      uses: actions/setup-node@v1
@@ -165,19 +195,23 @@ jobs:
    - uses: actions/download-artifact@v1
      with:
-        name: dist-macos-11.0
+        name: dist-aarch64-apple-darwin
+        path: dist
+    - uses: actions/download-artifact@v1
+      with:
+        name: dist-x86_64-apple-darwin
        path: dist
    - uses: actions/download-artifact@v1
      with:
-        name: dist-macos-latest
+        name: dist-x86_64-unknown-linux-gnu
        path: dist
    - uses: actions/download-artifact@v1
      with:
-        name: dist-ubuntu-16.04
+        name: dist-x86_64-pc-windows-msvc
        path: dist
    - uses: actions/download-artifact@v1
      with:
-        name: dist-windows-latest
+        name: dist-aarch64-pc-windows-msvc
        path: dist
    - run: ls -al ./dist
diff --git a/Cargo.lock b/Cargo.lock
index 4aaee3ab1..fe45f9dec 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,9 +2,9 @@
 # It is not intended for manual editing.
 [[package]]
 name = "addr2line"
-version = "0.14.0"
+version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c0929d69e78dd9bf5408269919fcbcaeb2e35e5d43e5815517cdc6a8e11a423"
+checksum = "a55f82cfe485775d02112886f4169bde0c5894d75e79ead7eafe7e40a25e45f7"
 dependencies = [
 "gimli",
 ]
@@ -132,7 +132,7 @@ version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d5a5f7b42f606b7f23674f6f4d877628350682bc40687d3fae65679a58d55345"
 dependencies = [
- "semver 0.11.0",
+ "semver",
 "serde",
 "serde_json",
 ]
@@ -168,9 +168,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 [[package]]
 name = "chalk-derive"
-version = "0.45.0"
+version = "0.47.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec7dacf94958d1a930b95d049d9443860859af59eadc77849392093eb577bcee"
+checksum = "3f00f6342a387edc822002d36a381e117afcac9f744951ff75fbf4a218edea5c"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -180,9 +180,9 @@ dependencies = [
 [[package]]
 name = "chalk-ir"
-version = "0.45.0"
+version = "0.47.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1a5b38ede247def17da87f4badb62396a5753db6048e2011d3089d8b3796c67"
+checksum = "c686e69913591ae753e5526e73cbee39db3d9b0a92cc9078ab780cabf1c70aa9"
 dependencies = [
 "bitflags",
 "chalk-derive",
@@ -191,9 +191,9 @@ dependencies = [
 [[package]]
 name = "chalk-recursive"
-version = "0.45.0"
+version = "0.47.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a18db146d7a023edc20ad094e8c2284451f7888719645004979617d1f17c041"
+checksum = "310fdcac0340dab4163b766baa8067266e3b909108d1ac1b5246c033bde63975"
 dependencies = [
 "chalk-derive",
 "chalk-ir",
@@ -204,9 +204,9 @@ dependencies = [
 [[package]]
 name = "chalk-solve"
-version = "0.45.0"
+version = "0.47.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f73e0de04a0f394e47ed8118e00541bcf681d7c3c2ef500fa743eb4cf3a4850"
+checksum = "c3c3252116111c3548f1164ab8d98c67c49848b3bde10dd11b650fd023e91c72"
 dependencies = [
 "chalk-derive",
 "chalk-ir",
@@ -488,19 +488,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
 [[package]]
-name = "generator"
-version = "0.6.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cdc09201b2e8ca1b19290cf7e65de2246b8e91fb6874279722189c4de7b94dc"
-dependencies = [
- "cc",
- "libc",
- "log",
- "rustc_version",
- "winapi 0.3.9",
-]
-[[package]]
 name = "gimli"
 version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -834,19 +821,6 @@ dependencies = [
 ]
 [[package]]
-name = "loom"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0e8460f2f2121162705187214720353c517b97bdfb3494c0b1e33d83ebe4bed"
-dependencies = [
- "cfg-if 0.1.10",
- "generator",
- "scoped-tls",
- "serde",
- "serde_json",
-]
-[[package]]
 name = "lsp-server"
 version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1394,9 +1368,9 @@ dependencies = [
 [[package]]
 name = "rustc-ap-rustc_lexer"
-version = "695.0.0"
+version = "697.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "390bad134705b0bff02cd9541ac66df751a91c3cc734c3369cd6151ca269caed"
+checksum = "67adbe260a0a11910624d6d28c0304fcf7b063e666682111005c83b09f73429d"
 dependencies = [
 "unicode-xid",
 ]
@@ -1414,15 +1388,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 [[package]]
-name = "rustc_version"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
-dependencies = [
- "semver 0.9.0",
-]
-[[package]]
 name = "ryu"
 version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1480,31 +1445,16 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 [[package]]
 name = "semver"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
-dependencies = [
- "semver-parser 0.7.0",
-]
-[[package]]
-name = "semver"
 version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6"
 dependencies = [
- "semver-parser 0.10.1",
+ "semver-parser",
 "serde",
 ]
 [[package]]
 name = "semver-parser"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
-[[package]]
-name = "semver-parser"
 version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42ef146c2ad5e5f4b037cd6ce2ebb775401729b19a82040c1beac9d36c7d1428"
@@ -1566,12 +1516,11 @@ dependencies = [
 [[package]]
 name = "sharded-slab"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b4921be914e16899a80adefb821f8ddb7974e3f1250223575a44ed994882127"
+checksum = "79c719719ee05df97490f80a45acfc99e5a30ce98a1e4fb67aee422745ae14e3"
 dependencies = [
 "lazy_static",
- "loom",
 ]
 [[package]]
@@ -1582,9 +1531,9 @@ checksum = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
 [[package]]
 name = "smallvec"
-version = "1.5.1"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae524f056d7d770e174287294f562e95044c68e88dec909a00d2094805db9d75"
+checksum = "1a55ca5f3b68e41c979bf8c46a6f1da892ca4db8f94023ce0bd32407573b1ac0"
 [[package]]
 name = "smol_str"
@@ -1615,9 +1564,9 @@ version = "0.0.0"
 [[package]]
 name = "syn"
-version = "1.0.56"
+version = "1.0.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9802ddde94170d186eeee5005b798d9c159fa970403f1be19976d0cfb939b72"
+checksum = "4211ce9909eb971f111059df92c45640aad50a619cf55cd76476be803c4c68e6"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1826,15 +1775,16 @@ dependencies = [
 [[package]]
 name = "tracing-tree"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43aac8afb493b08e1e1904956f7407c1e671b9c83b26a17e1bd83d6a3520e350"
+checksum = "023e80cdb7c8468b7aade1d756afa2acbe2ae0a6142a25ec664b5239d6ef2794"
 dependencies = [
 "ansi_term",
 "atty",
 "chrono",
 "termcolor",
 "tracing",
+ "tracing-log",
 "tracing-subscriber",
 ]
@@ -1854,9 +1804,9 @@ checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
 [[package]]
 name = "ungrammar"
-version = "1.5.0"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c11bffada52edc8f2a56160b286ea4640acf90ffcb21bded361ccb8ed43a1457"
+checksum = "f96cc1b6938f7c548fbcc630bac5c896ae77a130909829ab18b8eab78c51b7ee"
 [[package]]
 name = "unicase"
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),
    }