80 files changed, 2132 insertions, 1019 deletions
diff --git a/crates/assists/src/handlers/auto_import.rs b/crates/assists/src/handlers/auto_import.rs
index 37dd61266..d665837a2 100644
--- a/crates/assists/src/handlers/auto_import.rs
+++ b/crates/assists/src/handlers/auto_import.rs
@@ -98,7 +98,8 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
    let range = ctx.sema.original_range(import_assets.syntax_under_caret()).range;
    let group = import_group_message(import_assets.import_candidate());
-    let scope = ImportScope::find_insert_use_container(import_assets.syntax_under_caret(), ctx)?;
+    let scope =
+        ImportScope::find_insert_use_container(import_assets.syntax_under_caret(), &ctx.sema)?;
    for (import, _) in proposed_imports {
        acc.add_group(
            &group,
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 067afabf2..cac77c49b 100644
--- a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -143,8 +143,7 @@ fn insert_import(
    if let Some(mut mod_path) = mod_path {
        mod_path.segments.pop();
        mod_path.segments.push(variant_hir_name.clone());
-        let scope = ImportScope::find_insert_use_container(scope_node, ctx)?;
+        let scope = ImportScope::find_insert_use_container(scope_node, &ctx.sema)?;
        *rewriter += insert_use(&scope, mod_path_to_ast(&mod_path), ctx.config.insert_use.merge);
    }
    Some(())
diff --git a/crates/assists/src/handlers/ignore_test.rs b/crates/assists/src/handlers/ignore_test.rs
new file mode 100644
index 000000000..5096a0005
--- /dev/null
+++ b/crates/assists/src/handlers/ignore_test.rs
@@ -0,0 +1,103 @@
+use syntax::{
+    ast::{self, AttrsOwner},
+    AstNode, AstToken,
+};
+use crate::{utils::test_related_attribute, AssistContext, AssistId, AssistKind, Assists};
+// Assist: ignore_test
+//
+// Adds `#[ignore]` attribute to the test.
+//
+// ```
+// <|>#[test]
+// fn arithmetics {
+//     assert_eq!(2 + 2, 5);
+// }
+// ```
+// ->
+// ```
+// #[test]
+// #[ignore]
+// fn arithmetics {
+//     assert_eq!(2 + 2, 5);
+// }
+// ```
+pub(crate) fn ignore_test(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let attr: ast::Attr = ctx.find_node_at_offset()?;
+    let func = attr.syntax().parent().and_then(ast::Fn::cast)?;
+    let attr = test_related_attribute(&func)?;
+    match has_ignore_attribute(&func) {
+        None => acc.add(
+            AssistId("ignore_test", AssistKind::None),
+            "Ignore this test",
+            attr.syntax().text_range(),
+            |builder| builder.insert(attr.syntax().text_range().end(), &format!("\n#[ignore]")),
+        ),
+        Some(ignore_attr) => acc.add(
+            AssistId("unignore_test", AssistKind::None),
+            "Re-enable this test",
+            ignore_attr.syntax().text_range(),
+            |builder| {
+                builder.delete(ignore_attr.syntax().text_range());
+                let whitespace = ignore_attr
+                    .syntax()
+                    .next_sibling_or_token()
+                    .and_then(|x| x.into_token())
+                    .and_then(ast::Whitespace::cast);
+                if let Some(whitespace) = whitespace {
+                    builder.delete(whitespace.syntax().text_range());
+                }
+            },
+        ),
+    }
+}
+fn has_ignore_attribute(fn_def: &ast::Fn) -> Option<ast::Attr> {
+    fn_def.attrs().find_map(|attr| {
+        if attr.path()?.syntax().text() == "ignore" {
+            Some(attr)
+        } else {
+            None
+        }
+    })
+}
+#[cfg(test)]
+mod tests {
+    use super::ignore_test;
+    use crate::tests::check_assist;
+    #[test]
+    fn test_base_case() {
+        check_assist(
+            ignore_test,
+            r#"
+            #[test<|>]
+            fn test() {}
+            "#,
+            r#"
+            #[test]
+            #[ignore]
+            fn test() {}
+            "#,
+        )
+    }
+    #[test]
+    fn test_unignore() {
+        check_assist(
+            ignore_test,
+            r#"
+            #[test<|>]
+            #[ignore]
+            fn test() {}
+            "#,
+            r#"
+            #[test]
+            fn test() {}
+            "#,
+        )
+    }
+}
diff --git a/crates/assists/src/handlers/remove_dbg.rs b/crates/assists/src/handlers/remove_dbg.rs
index 9731344b8..eae6367c1 100644
--- a/crates/assists/src/handlers/remove_dbg.rs
+++ b/crates/assists/src/handlers/remove_dbg.rs
@@ -1,6 +1,6 @@
 use syntax::{
    ast::{self, AstNode},
-    SyntaxElement, SyntaxKind, TextRange, TextSize, T,
+    match_ast, SyntaxElement, SyntaxKind, TextRange, TextSize, T,
 };
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -49,12 +49,29 @@ fn adjusted_macro_contents(macro_call: &ast::MacroCall) -> Option<String> {
        macro_text_with_brackets.len() - TextSize::of(')'),
    ));
-    let is_leaf = macro_call.syntax().next_sibling().is_none();
+    Some(
-    Some(if !is_leaf && needs_parentheses_around_macro_contents(contents) {
+        if !is_leaf_or_control_flow_expr(macro_call)
-        format!("({})", macro_text_in_brackets)
+            && needs_parentheses_around_macro_contents(contents)
-    } else {
+        {
-        macro_text_in_brackets.to_string()
+            format!("({})", macro_text_in_brackets)
-    })
+        } else {
+            macro_text_in_brackets.to_string()
+        },
+    )
+}
+fn is_leaf_or_control_flow_expr(macro_call: &ast::MacroCall) -> bool {
+    macro_call.syntax().next_sibling().is_none()
+        || match macro_call.syntax().parent() {
+            Some(parent) => match_ast! {
+                match parent {
+                    ast::Condition(_it) => true,
+                    ast::MatchExpr(_it) => true,
+                    _ => false,
+                }
+            },
+            None => false,
+        }
 }
 /// Verifies that the given macro_call actually matches the given name
@@ -361,4 +378,44 @@ fn main() {
            r#"let res = (foo..=bar).foo();"#,
        );
    }
+    #[test]
+    fn test_remove_dbg_followed_by_block() {
+        check_assist(
+            remove_dbg,
+            r#"fn foo() {
+    if <|>dbg!(x || y) {}
+}"#,
+            r#"fn foo() {
+    if x || y {}
+}"#,
+        );
+        check_assist(
+            remove_dbg,
+            r#"fn foo() {
+    while let foo = <|>dbg!(&x) {}
+}"#,
+            r#"fn foo() {
+    while let foo = &x {}
+}"#,
+        );
+        check_assist(
+            remove_dbg,
+            r#"fn foo() {
+    if let foo = <|>dbg!(&x) {}
+}"#,
+            r#"fn foo() {
+    if let foo = &x {}
+}"#,
+        );
+        check_assist(
+            remove_dbg,
+            r#"fn foo() {
+    match <|>dbg!(&x) {}
+}"#,
+            r#"fn foo() {
+    match &x {}
+}"#,
+        );
+    }
 }
diff --git a/crates/assists/src/handlers/replace_derive_with_manual_impl.rs b/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
index 82625516c..453a6cebf 100644
--- a/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
+++ b/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
@@ -62,19 +62,21 @@ pub(crate) fn replace_derive_with_manual_impl(
    let current_module = ctx.sema.scope(annotated_name.syntax()).module()?;
    let current_crate = current_module.krate();
-    let found_traits = imports_locator::find_imports(&ctx.sema, current_crate, trait_token.text())
+    let found_traits =
-        .into_iter()
+        imports_locator::find_exact_imports(&ctx.sema, current_crate, trait_token.text())
-        .filter_map(|candidate: either::Either<hir::ModuleDef, hir::MacroDef>| match candidate {
+            .filter_map(
-            either::Either::Left(hir::ModuleDef::Trait(trait_)) => Some(trait_),
+                |candidate: either::Either<hir::ModuleDef, hir::MacroDef>| match candidate {
-            _ => None,
+                    either::Either::Left(hir::ModuleDef::Trait(trait_)) => Some(trait_),
-        })
+                    _ => None,
-        .flat_map(|trait_| {
+                },
-            current_module
+            )
-                .find_use_path(ctx.sema.db, hir::ModuleDef::Trait(trait_))
+            .flat_map(|trait_| {
-                .as_ref()
+                current_module
-                .map(mod_path_to_ast)
+                    .find_use_path(ctx.sema.db, hir::ModuleDef::Trait(trait_))
-                .zip(Some(trait_))
+                    .as_ref()
-        });
+                    .map(mod_path_to_ast)
+                    .zip(Some(trait_))
+            });
    let mut no_traits_found = true;
    for (trait_path, trait_) in found_traits.inspect(|_| no_traits_found = false) {
diff --git a/crates/assists/src/handlers/replace_qualified_name_with_use.rs b/crates/assists/src/handlers/replace_qualified_name_with_use.rs
index d7e1d9580..a66db9ae3 100644
--- a/crates/assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/assists/src/handlers/replace_qualified_name_with_use.rs
@@ -34,7 +34,7 @@ pub(crate) fn replace_qualified_name_with_use(
    }
    let target = path.syntax().text_range();
-    let scope = ImportScope::find_insert_use_container(path.syntax(), ctx)?;
+    let scope = ImportScope::find_insert_use_container(path.syntax(), &ctx.sema)?;
    let syntax = scope.as_syntax_node();
    acc.add(
        AssistId("replace_qualified_name_with_use", AssistKind::RefactorRewrite),
diff --git a/crates/assists/src/handlers/unwrap_block.rs b/crates/assists/src/handlers/unwrap_block.rs
index 36ef871b9..676db7137 100644
--- a/crates/assists/src/handlers/unwrap_block.rs
+++ b/crates/assists/src/handlers/unwrap_block.rs
@@ -3,7 +3,7 @@ use syntax::{
        self,
        edit::{AstNodeEdit, IndentLevel},
    },
-    AstNode, TextRange, T,
+    AstNode, SyntaxKind, TextRange, T,
 };
 use crate::{utils::unwrap_trivial_block, AssistContext, AssistId, AssistKind, Assists};
@@ -31,11 +31,21 @@ pub(crate) fn unwrap_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
    let l_curly_token = ctx.find_token_syntax_at_offset(T!['{'])?;
    let mut block = ast::BlockExpr::cast(l_curly_token.parent())?;
+    let target = block.syntax().text_range();
    let mut parent = block.syntax().parent()?;
    if ast::MatchArm::can_cast(parent.kind()) {
        parent = parent.ancestors().find(|it| ast::MatchExpr::can_cast(it.kind()))?
    }
+    if matches!(parent.kind(), SyntaxKind::BLOCK_EXPR | SyntaxKind::EXPR_STMT) {
+        return acc.add(assist_id, assist_label, target, |builder| {
+            builder.replace(
+                block.syntax().text_range(),
+                update_expr_string(block.to_string(), &[' ', '{', '\n']),
+            );
+        });
+    }
    let parent = ast::Expr::cast(parent)?;
    match parent.clone() {
@@ -48,7 +58,6 @@ pub(crate) fn unwrap_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
                    // For `else if` blocks
                    let ancestor_then_branch = ancestor.then_branch()?;
-                    let target = then_branch.syntax().text_range();
                    return acc.add(assist_id, assist_label, target, |edit| {
                        let range_to_del_else_if = TextRange::new(
                            ancestor_then_branch.syntax().text_range().end(),
@@ -68,7 +77,6 @@ pub(crate) fn unwrap_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
                    });
                }
            } else {
-                let target = block.syntax().text_range();
                return acc.add(assist_id, assist_label, target, |edit| {
                    let range_to_del = TextRange::new(
                        then_branch.syntax().text_range().end(),
@@ -84,7 +92,6 @@ pub(crate) fn unwrap_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
    };
    let unwrapped = unwrap_trivial_block(block);
-    let target = unwrapped.syntax().text_range();
    acc.add(assist_id, assist_label, target, |builder| {
        builder.replace(
            parent.syntax().text_range(),
@@ -112,31 +119,89 @@ mod tests {
    use super::*;
    #[test]
+    fn unwrap_tail_expr_block() {
+        check_assist(
+            unwrap_block,
+            r#"
+fn main() {
+    <|>{
+        92
+    }
+}
+"#,
+            r#"
+fn main() {
+    92
+}
+"#,
+        )
+    }
+    #[test]
+    fn unwrap_stmt_expr_block() {
+        check_assist(
+            unwrap_block,
+            r#"
+fn main() {
+    <|>{
+        92;
+    }
+    ()
+}
+"#,
+            r#"
+fn main() {
+    92;
+    ()
+}
+"#,
+        );
+        // Pedantically, we should add an `;` here...
+        check_assist(
+            unwrap_block,
+            r#"
+fn main() {
+    <|>{
+        92
+    }
+    ()
+}
+"#,
+            r#"
+fn main() {
+    92
+    ()
+}
+"#,
+        );
+    }
+    #[test]
    fn simple_if() {
        check_assist(
            unwrap_block,
            r#"
-            fn main() {
+fn main() {
-                bar();
+    bar();
-                if true {<|>
+    if true {<|>
-                    foo();
+        foo();
-                    //comment
+        //comment
-                    bar();
+        bar();
-                } else {
+    } else {
-                    println!("bar");
+        println!("bar");
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            fn main() {
+fn main() {
-                bar();
+    bar();
-                foo();
+    foo();
-                //comment
+    //comment
-                bar();
+    bar();
-            }
+}
-            "#,
+"#,
        );
    }
@@ -145,30 +210,30 @@ mod tests {
        check_assist(
            unwrap_block,
            r#"
-            fn main() {
+fn main() {
-                bar();
+    bar();
-                if true {
+    if true {
-                    foo();
+        foo();
-                    //comment
+        //comment
-                    bar();
+        bar();
-                } else {<|>
+    } else {<|>
-                    println!("bar");
+        println!("bar");
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            fn main() {
+fn main() {
-                bar();
+    bar();
-                if true {
+    if true {
-                    foo();
+        foo();
-                    //comment
+        //comment
-                    bar();
+        bar();
-                }
+    }
-                println!("bar");
+    println!("bar");
-            }
+}
-            "#,
+"#,
        );
    }
@@ -177,32 +242,32 @@ mod tests {
        check_assist(
            unwrap_block,
            r#"
-            fn main() {
+fn main() {
-                //bar();
+    //bar();
-                if true {
+    if true {
-                    println!("true");
+        println!("true");
-                    //comment
+        //comment
-                    //bar();
+        //bar();
-                } else if false {<|>
+    } else if false {<|>
-                    println!("bar");
+        println!("bar");
-                } else {
+    } else {
-                    println!("foo");
+        println!("foo");
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            fn main() {
+fn main() {
-                //bar();
+    //bar();
-                if true {
+    if true {
-                    println!("true");
+        println!("true");
-                    //comment
+        //comment
-                    //bar();
+        //bar();
-                }
+    }
-                println!("bar");
+    println!("bar");
-            }
+}
-            "#,
+"#,
        );
    }
@@ -211,34 +276,34 @@ mod tests {
        check_assist(
            unwrap_block,
            r#"
-            fn main() {
+fn main() {
-                //bar();
+    //bar();
-                if true {
+    if true {
-                    println!("true");
+        println!("true");
-                    //comment
+        //comment
-                    //bar();
+        //bar();
-                } else if false {
+    } else if false {
-                    println!("bar");
+        println!("bar");
-                } else if true {<|>
+    } else if true {<|>
-                    println!("foo");
+        println!("foo");
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            fn main() {
+fn main() {
-                //bar();
+    //bar();
-                if true {
+    if true {
-                    println!("true");
+        println!("true");
-                    //comment
+        //comment
-                    //bar();
+        //bar();
-                } else if false {
+    } else if false {
-                    println!("bar");
+        println!("bar");
-                }
+    }
-                println!("foo");
+    println!("foo");
-            }
+}
-            "#,
+"#,
        );
    }
@@ -247,38 +312,38 @@ mod tests {
        check_assist(
            unwrap_block,
            r#"
-            fn main() {
+fn main() {
-                //bar();
+    //bar();
-                if true {
+    if true {
-                    println!("true");
+        println!("true");
-                    //comment
+        //comment
-                    //bar();
+        //bar();
-                } else if false {
+    } else if false {
-                    println!("bar");
+        println!("bar");
-                } else if true {
+    } else if true {
-                    println!("foo");
+        println!("foo");
-                } else {<|>
+    } else {<|>
-                    println!("else");
+        println!("else");
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            fn main() {
+fn main() {
-                //bar();
+    //bar();
-                if true {
+    if true {
-                    println!("true");
+        println!("true");
-                    //comment
+        //comment
-                    //bar();
+        //bar();
-                } else if false {
+    } else if false {
-                    println!("bar");
+        println!("bar");
-                } else if true {
+    } else if true {
-                    println!("foo");
+        println!("foo");
-                }
+    }
-                println!("else");
+    println!("else");
-            }
+}
-            "#,
+"#,
        );
    }
@@ -287,36 +352,36 @@ mod tests {
        check_assist(
            unwrap_block,
            r#"
-            fn main() {
+fn main() {
-                //bar();
+    //bar();
-                if true {
+    if true {
-                    println!("true");
+        println!("true");
-                    //comment
+        //comment
-                    //bar();
+        //bar();
-                } else if false {
+    } else if false {
-                    println!("bar");
+        println!("bar");
-                } else if true {<|>
+    } else if true {<|>
-                    println!("foo");
+        println!("foo");
-                } else {
+    } else {
-                    println!("else");
+        println!("else");
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            fn main() {
+fn main() {
-                //bar();
+    //bar();
-                if true {
+    if true {
-                    println!("true");
+        println!("true");
-                    //comment
+        //comment
-                    //bar();
+        //bar();
-                } else if false {
+    } else if false {
-                    println!("bar");
+        println!("bar");
-                }
+    }
-                println!("foo");
+    println!("foo");
-            }
+}
-            "#,
+"#,
        );
    }
@@ -325,18 +390,18 @@ mod tests {
        check_assist_not_applicable(
            unwrap_block,
            r#"
-            fn main() {
+fn main() {
-                bar();<|>
+    bar();<|>
-                if true {
+    if true {
-                    foo();
+        foo();
-                    //comment
+        //comment
-                    bar();
+        bar();
-                } else {
+    } else {
-                    println!("bar");
+        println!("bar");
-                }
+    }
-            }
+}
-            "#,
+"#,
        );
    }
@@ -345,31 +410,31 @@ mod tests {
        check_assist(
            unwrap_block,
            r#"
-            fn main() {
+fn main() {
-                for i in 0..5 {<|>
+    for i in 0..5 {<|>
-                    if true {
+        if true {
-                        foo();
+            foo();
-                        //comment
+            //comment
-                        bar();
+            bar();
-                    } else {
+        } else {
-                        println!("bar");
+            println!("bar");
-                    }
+        }
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            fn main() {
+fn main() {
-                if true {
+    if true {
-                    foo();
+        foo();
-                    //comment
+        //comment
-                    bar();
+        bar();
-                } else {
+    } else {
-                    println!("bar");
+        println!("bar");
-                }
+    }
-            }
+}
-            "#,
+"#,
        );
    }
@@ -378,29 +443,29 @@ mod tests {
        check_assist(
            unwrap_block,
            r#"
-            fn main() {
+fn main() {
-                for i in 0..5 {
+    for i in 0..5 {
-                    if true {<|>
+        if true {<|>
-                        foo();
+            foo();
-                        //comment
+            //comment
-                        bar();
+            bar();
-                    } else {
+        } else {
-                        println!("bar");
+            println!("bar");
-                    }
+        }
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            fn main() {
+fn main() {
-                for i in 0..5 {
+    for i in 0..5 {
-                    foo();
+        foo();
-                    //comment
+        //comment
-                    bar();
+        bar();
-                }
+    }
-            }
+}
-            "#,
+"#,
        );
    }
@@ -409,31 +474,31 @@ mod tests {
        check_assist(
            unwrap_block,
            r#"
-            fn main() {
+fn main() {
-                loop {<|>
+    loop {<|>
-                    if true {
+        if true {
-                        foo();
+            foo();
-                        //comment
+            //comment
-                        bar();
+            bar();
-                    } else {
+        } else {
-                        println!("bar");
+            println!("bar");
-                    }
+        }
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            fn main() {
+fn main() {
-                if true {
+    if true {
-                    foo();
+        foo();
-                    //comment
+        //comment
-                    bar();
+        bar();
-                } else {
+    } else {
-                    println!("bar");
+        println!("bar");
-                }
+    }
-            }
+}
-            "#,
+"#,
        );
    }
@@ -442,31 +507,31 @@ mod tests {
        check_assist(
            unwrap_block,
            r#"
-            fn main() {
+fn main() {
-                while true {<|>
+    while true {<|>
-                    if true {
+        if true {
-                        foo();
+            foo();
-                        //comment
+            //comment
-                        bar();
+            bar();
-                    } else {
+        } else {
-                        println!("bar");
+            println!("bar");
-                    }
+        }
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            fn main() {
+fn main() {
-                if true {
+    if true {
-                    foo();
+        foo();
-                    //comment
+        //comment
-                    bar();
+        bar();
-                } else {
+    } else {
-                    println!("bar");
+        println!("bar");
-                }
+    }
-            }
+}
-            "#,
+"#,
        );
    }
@@ -499,19 +564,19 @@ fn main() {
        check_assist_not_applicable(
            unwrap_block,
            r#"
-            fn main() {
+fn main() {
-                while true {
+    while true {
-                    if true {
+        if true {
-                        foo();<|>
+            foo();<|>
-                        //comment
+            //comment
-                        bar();
+            bar();
-                    } else {
+        } else {
-                        println!("bar");
+            println!("bar");
-                    }
+        }
-                }
+    }
-            }
+}
-            "#,
+"#,
        );
    }
 }
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs
index e8d81b33d..17e9312db 100644
--- a/crates/assists/src/lib.rs
+++ b/crates/assists/src/lib.rs
@@ -141,6 +141,7 @@ mod handlers {
    mod generate_function;
    mod generate_impl;
    mod generate_new;
+    mod ignore_test;
    mod infer_function_return_type;
    mod inline_local_variable;
    mod introduce_named_lifetime;
@@ -189,6 +190,7 @@ mod handlers {
            generate_function::generate_function,
            generate_impl::generate_impl,
            generate_new::generate_new,
+            ignore_test::ignore_test,
            infer_function_return_type::infer_function_return_type,
            inline_local_variable::inline_local_variable,
            introduce_named_lifetime::introduce_named_lifetime,
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index dbf4f21aa..5a9d1a01b 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -474,6 +474,26 @@ impl<T: Clone> Ctx<T> {
 }
 #[test]
+fn doctest_ignore_test() {
+    check_doc_test(
+        "ignore_test",
+        r#####"
+<|>#[test]
+fn arithmetics {
+    assert_eq!(2 + 2, 5);
+}
+"#####,
+        r#####"
+#[test]
+#[ignore]
+fn arithmetics {
+    assert_eq!(2 + 2, 5);
+}
+"#####,
+    )
+}
+#[test]
 fn doctest_infer_function_return_type() {
    check_doc_test(
        "infer_function_return_type",
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index 7bd338e99..66c0cdd5f 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -9,6 +9,7 @@ use ide_db::RootDatabase;
 use itertools::Itertools;
 use syntax::{
    ast::edit::AstNodeEdit,
+    ast::AttrsOwner,
    ast::NameOwner,
    ast::{self, edit, make, ArgListOwner},
    AstNode, Direction,
@@ -21,8 +22,7 @@ use crate::{
    ast_transform::{self, AstTransform, QualifyPaths, SubstituteTypeParams},
 };
-pub use insert_use::MergeBehaviour;
+pub use insert_use::{insert_use, ImportScope, MergeBehaviour};
-pub(crate) use insert_use::{insert_use, ImportScope};
 pub fn mod_path_to_ast(path: &hir::ModPath) -> ast::Path {
    let mut segments = Vec::new();
@@ -82,6 +82,23 @@ pub fn extract_trivial_expression(block: &ast::BlockExpr) -> Option<ast::Expr> {
    None
 }
+/// This is a method with a heuristics to support test methods annotated with custom test annotations, such as
+/// `#[test_case(...)]`, `#[tokio::test]` and similar.
+/// Also a regular `#[test]` annotation is supported.
+///
+/// It may produce false positives, for example, `#[wasm_bindgen_test]` requires a different command to run the test,
+/// but it's better than not to have the runnables for the tests at all.
+pub fn test_related_attribute(fn_def: &ast::Fn) -> Option<ast::Attr> {
+    fn_def.attrs().find_map(|attr| {
+        let path = attr.path()?;
+        if path.syntax().text().to_string().contains("test") {
+            Some(attr)
+        } else {
+            None
+        }
+    })
+}
 #[derive(Copy, Clone, PartialEq)]
 pub enum DefaultMethods {
    Only,
diff --git a/crates/assists/src/utils/import_assets.rs b/crates/assists/src/utils/import_assets.rs
index f47edbb76..ff5c0e78e 100644
--- a/crates/assists/src/utils/import_assets.rs
+++ b/crates/assists/src/utils/import_assets.rs
@@ -179,21 +179,25 @@ impl ImportAssets {
            }
        };
-        let mut res = imports_locator::find_imports(sema, current_crate, &self.get_search_query())
+        let mut res =
-            .into_iter()
+            imports_locator::find_exact_imports(sema, current_crate, &self.get_search_query())
-            .filter_map(filter)
+                .filter_map(filter)
-            .filter_map(|candidate| {
+                .filter_map(|candidate| {
-                let item: hir::ItemInNs = candidate.either(Into::into, Into::into);
+                    let item: hir::ItemInNs = candidate.either(Into::into, Into::into);
-                if let Some(prefix_kind) = prefixed {
+                    if let Some(prefix_kind) = prefixed {
-                    self.module_with_name_to_import.find_use_path_prefixed(db, item, prefix_kind)
+                        self.module_with_name_to_import.find_use_path_prefixed(
-                } else {
+                            db,
-                    self.module_with_name_to_import.find_use_path(db, item)
+                            item,
-                }
+                            prefix_kind,
-                .map(|path| (path, item))
+                        )
-            })
+                    } else {
-            .filter(|(use_path, _)| !use_path.segments.is_empty())
+                        self.module_with_name_to_import.find_use_path(db, item)
-            .take(20)
+                    }
-            .collect::<Vec<_>>();
+                    .map(|path| (path, item))
+                })
+                .filter(|(use_path, _)| use_path.len() > 1)
+                .take(20)
+                .collect::<Vec<_>>();
        res.sort_by_key(|(path, _)| path.clone());
        res
    }
diff --git a/crates/assists/src/utils/insert_use.rs b/crates/assists/src/utils/insert_use.rs
index af3fc96b6..423782a0e 100644
--- a/crates/assists/src/utils/insert_use.rs
+++ b/crates/assists/src/utils/insert_use.rs
@@ -1,6 +1,8 @@
 //! Handle syntactic aspects of inserting a new `use`.
 use std::{cmp::Ordering, iter::successors};
+use hir::Semantics;
+use ide_db::RootDatabase;
 use itertools::{EitherOrBoth, Itertools};
 use syntax::{
    algo::SyntaxRewriter,
@@ -13,8 +15,8 @@ use syntax::{
 };
 use test_utils::mark;
-#[derive(Debug)]
+#[derive(Debug, Clone)]
-pub(crate) enum ImportScope {
+pub enum ImportScope {
    File(ast::SourceFile),
    Module(ast::ItemList),
 }
@@ -31,14 +33,14 @@ impl ImportScope {
    }
    /// Determines the containing syntax node in which to insert a `use` statement affecting `position`.
-    pub(crate) fn find_insert_use_container(
+    pub fn find_insert_use_container(
        position: &SyntaxNode,
-        ctx: &crate::assist_context::AssistContext,
+        sema: &Semantics<'_, RootDatabase>,
    ) -> Option<Self> {
-        ctx.sema.ancestors_with_macros(position.clone()).find_map(Self::from)
+        sema.ancestors_with_macros(position.clone()).find_map(Self::from)
    }
-    pub(crate) fn as_syntax_node(&self) -> &SyntaxNode {
+    pub fn as_syntax_node(&self) -> &SyntaxNode {
        match self {
            ImportScope::File(file) => file.syntax(),
            ImportScope::Module(item_list) => item_list.syntax(),
@@ -88,7 +90,7 @@ fn is_inner_comment(token: SyntaxToken) -> bool {
 }
 /// Insert an import path into the given file/node. A `merge` value of none indicates that no import merging is allowed to occur.
-pub(crate) fn insert_use<'a>(
+pub fn insert_use<'a>(
    scope: &ImportScope,
    path: ast::Path,
    merge: Option<MergeBehaviour>,
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index 31907ed98..98ba372ad 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -225,7 +225,10 @@ impl CrateGraph {
        to: CrateId,
    ) -> Result<(), CyclicDependenciesError> {
        if self.dfs_find(from, to, &mut FxHashSet::default()) {
-            return Err(CyclicDependenciesError);
+            return Err(CyclicDependenciesError {
+                from: (from, self[from].display_name.clone()),
+                to: (to, self[to].display_name.clone()),
+            });
        }
        self.arena.get_mut(&from).unwrap().add_dep(name, to);
        Ok(())
@@ -421,7 +424,20 @@ impl fmt::Display for ParseEditionError {
 impl std::error::Error for ParseEditionError {}
 #[derive(Debug)]
-pub struct CyclicDependenciesError;
+pub struct CyclicDependenciesError {
+    from: (CrateId, Option<CrateDisplayName>),
+    to: (CrateId, Option<CrateDisplayName>),
+}
+impl fmt::Display for CyclicDependenciesError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let render = |(id, name): &(CrateId, Option<CrateDisplayName>)| match name {
+            Some(it) => format!("{}({:?})", it, id),
+            None => format!("{:?}", id),
+        };
+        write!(f, "cyclic deps: {} -> {}", render(&self.from), render(&self.to))
+    }
+}
 #[cfg(test)]
 mod tests {
diff --git a/crates/cfg/src/lib.rs b/crates/cfg/src/lib.rs
index d0e08cf5f..d88ecf8b0 100644
--- a/crates/cfg/src/lib.rs
+++ b/crates/cfg/src/lib.rs
@@ -41,12 +41,6 @@ impl CfgOptions {
        self.enabled.insert(CfgAtom::KeyValue { key, value });
    }
-    pub fn append(&mut self, other: &CfgOptions) {
-        for atom in &other.enabled {
-            self.enabled.insert(atom.clone());
-        }
-    }
    pub fn apply_diff(&mut self, diff: CfgDiff) {
        for atom in diff.enable {
            self.enabled.insert(atom);
diff --git a/crates/completion/Cargo.toml b/crates/completion/Cargo.toml
index 3015ec9e0..e7df9d955 100644
--- a/crates/completion/Cargo.toml
+++ b/crates/completion/Cargo.toml
@@ -13,6 +13,7 @@ doctest = false
 itertools = "0.9.0"
 log = "0.4.8"
 rustc-hash = "1.1.0"
+either = "1.6.1"
 assists = { path = "../assists", version = "0.0.0" }
 stdx = { path = "../stdx", version = "0.0.0" }
diff --git a/crates/completion/src/completions.rs b/crates/completion/src/completions.rs
index 75dbb1a23..9b7d6c580 100644
--- a/crates/completion/src/completions.rs
+++ b/crates/completion/src/completions.rs
@@ -90,7 +90,7 @@ impl Completions {
            Some(it) => it,
            None => return,
        };
-        if let Some(item) = render_macro(RenderContext::new(ctx), name, macro_) {
+        if let Some(item) = render_macro(RenderContext::new(ctx), None, name, macro_) {
            self.add(item);
        }
    }
@@ -101,7 +101,7 @@ impl Completions {
        func: hir::Function,
        local_name: Option<String>,
    ) {
-        let item = render_fn(RenderContext::new(ctx), local_name, func);
+        let item = render_fn(RenderContext::new(ctx), None, local_name, func);
        self.add(item)
    }
@@ -123,7 +123,7 @@ impl Completions {
        variant: hir::EnumVariant,
        path: ModPath,
    ) {
-        let item = render_enum_variant(RenderContext::new(ctx), None, variant, Some(path));
+        let item = render_enum_variant(RenderContext::new(ctx), None, None, variant, Some(path));
        self.add(item);
    }
@@ -133,7 +133,7 @@ impl Completions {
        variant: hir::EnumVariant,
        local_name: Option<String>,
    ) {
-        let item = render_enum_variant(RenderContext::new(ctx), local_name, variant, None);
+        let item = render_enum_variant(RenderContext::new(ctx), None, local_name, variant, None);
        self.add(item);
    }
 }
diff --git a/crates/completion/src/completions/pattern.rs b/crates/completion/src/completions/pattern.rs
index 7ab7f09fe..4f63ff0ef 100644
--- a/crates/completion/src/completions/pattern.rs
+++ b/crates/completion/src/completions/pattern.rs
@@ -4,7 +4,7 @@ use crate::{CompletionContext, Completions};
 /// Completes constats and paths in patterns.
 pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.is_pat_binding_or_const {
+    if !(ctx.is_pat_binding_or_const || ctx.is_irrefutable_let_pat_binding) {
        return;
    }
    if ctx.record_pat_syntax.is_some() {
@@ -14,20 +14,27 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
    // FIXME: ideally, we should look at the type we are matching against and
    // suggest variants + auto-imports
    ctx.scope.process_all_names(&mut |name, res| {
-        match &res {
+        let add_resolution = match &res {
-            hir::ScopeDef::ModuleDef(def) => match def {
+            hir::ScopeDef::ModuleDef(def) => {
-                hir::ModuleDef::Adt(hir::Adt::Enum(..))
+                if ctx.is_irrefutable_let_pat_binding {
-                | hir::ModuleDef::Adt(hir::Adt::Struct(..))
+                    matches!(def, hir::ModuleDef::Adt(hir::Adt::Struct(_)))
-                | hir::ModuleDef::EnumVariant(..)
+                } else {
-                | hir::ModuleDef::Const(..)
+                    matches!(
-                | hir::ModuleDef::Module(..) => (),
+                        def,
-                _ => return,
+                        hir::ModuleDef::Adt(hir::Adt::Enum(..))
-            },
+                            | hir::ModuleDef::Adt(hir::Adt::Struct(..))
-            hir::ScopeDef::MacroDef(_) => (),
+                            | hir::ModuleDef::EnumVariant(..)
-            _ => return,
+                            | hir::ModuleDef::Const(..)
+                            | hir::ModuleDef::Module(..)
+                    )
+                }
+            }
+            hir::ScopeDef::MacroDef(_) => true,
+            _ => false,
        };
+        if add_resolution {
-        acc.add_resolution(ctx, name.to_string(), &res)
+            acc.add_resolution(ctx, name.to_string(), &res);
+        }
    });
 }
@@ -85,4 +92,26 @@ fn foo() {
            "#]],
        );
    }
+    #[test]
+    fn completes_in_irrefutable_let() {
+        check(
+            r#"
+enum E { X }
+use self::E::X;
+const Z: E = E::X;
+mod m {}
+static FOO: E = E::X;
+struct Bar { f: u32 }
+fn foo() {
+   let <|>
+}
+"#,
+            expect![[r#"
+                st Bar
+            "#]],
+        );
+    }
 }
diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs
index 7df58e1da..3bd776905 100644
--- a/crates/completion/src/completions/unqualified_path.rs
+++ b/crates/completion/src/completions/unqualified_path.rs
@@ -1,10 +1,16 @@
 //! Completion of names from the current scope, e.g. locals and imported items.
+use assists::utils::ImportScope;
+use either::Either;
 use hir::{Adt, ModuleDef, ScopeDef, Type};
+use ide_db::imports_locator;
 use syntax::AstNode;
 use test_utils::mark;
-use crate::{CompletionContext, Completions};
+use crate::{
+    render::{render_resolution_with_import, RenderContext},
+    CompletionContext, Completions,
+};
 pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionContext) {
    if !(ctx.is_trivial_path || ctx.is_pat_binding_or_const) {
@@ -37,6 +43,10 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
        }
        acc.add_resolution(ctx, name.to_string(), &res)
    });
+    if ctx.config.enable_experimental_completions {
+        fuzzy_completion(acc, ctx).unwrap_or_default()
+    }
 }
 fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &Type) {
@@ -63,6 +73,47 @@ fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &T
    }
 }
+fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
+    let _p = profile::span("fuzzy_completion");
+    let current_module = ctx.scope.module()?;
+    let anchor = ctx.name_ref_syntax.as_ref()?;
+    let import_scope = ImportScope::find_insert_use_container(anchor.syntax(), &ctx.sema)?;
+    let potential_import_name = ctx.token.to_string();
+    let possible_imports = imports_locator::find_similar_imports(
+        &ctx.sema,
+        ctx.krate?,
+        &potential_import_name,
+        50,
+        true,
+    )
+    .filter_map(|import_candidate| {
+        Some(match import_candidate {
+            Either::Left(module_def) => {
+                (current_module.find_use_path(ctx.db, module_def)?, ScopeDef::ModuleDef(module_def))
+            }
+            Either::Right(macro_def) => {
+                (current_module.find_use_path(ctx.db, macro_def)?, ScopeDef::MacroDef(macro_def))
+            }
+        })
+    })
+    .filter(|(mod_path, _)| mod_path.len() > 1)
+    .take(20)
+    .filter_map(|(import_path, definition)| {
+        render_resolution_with_import(
+            RenderContext::new(ctx),
+            import_path.clone(),
+            import_scope.clone(),
+            ctx.config.merge,
+            &definition,
+        )
+    });
+    acc.add_all(possible_imports);
+    Some(())
+}
 #[cfg(test)]
 mod tests {
    use expect_test::{expect, Expect};
@@ -676,4 +727,85 @@ impl My<|>
            "#]],
        )
    }
+    #[test]
+    fn function_fuzzy_completion() {
+        check_edit(
+            "stdin",
+            r#"
+//- /lib.rs crate:dep
+pub mod io {
+    pub fn stdin() {}
+};
+//- /main.rs crate:main deps:dep
+fn main() {
+    stdi<|>
+}
+"#,
+            r#"
+use dep::io::stdin;
+fn main() {
+    stdin()$0
+}
+"#,
+        );
+    }
+    #[test]
+    fn macro_fuzzy_completion() {
+        check_edit(
+            "macro_with_curlies!",
+            r#"
+//- /lib.rs crate:dep
+/// Please call me as macro_with_curlies! {}
+#[macro_export]
+macro_rules! macro_with_curlies {
+    () => {}
+}
+//- /main.rs crate:main deps:dep
+fn main() {
+    curli<|>
+}
+"#,
+            r#"
+use dep::macro_with_curlies;
+fn main() {
+    macro_with_curlies! {$0}
+}
+"#,
+        );
+    }
+    #[test]
+    fn struct_fuzzy_completion() {
+        check_edit(
+            "ThirdStruct",
+            r#"
+//- /lib.rs crate:dep
+pub struct FirstStruct;
+pub mod some_module {
+    pub struct SecondStruct;
+    pub struct ThirdStruct;
+}
+//- /main.rs crate:main deps:dep
+use dep::{FirstStruct, some_module::SecondStruct};
+fn main() {
+    this<|>
+}
+"#,
+            r#"
+use dep::{FirstStruct, some_module::{SecondStruct, ThirdStruct}};
+fn main() {
+    ThirdStruct
+}
+"#,
+        );
+    }
 }
diff --git a/crates/completion/src/config.rs b/crates/completion/src/config.rs
index 71b49ace8..f50735372 100644
--- a/crates/completion/src/config.rs
+++ b/crates/completion/src/config.rs
@@ -4,12 +4,16 @@
 //! module, and we use to statically check that we only produce snippet
 //! completions if we are allowed to.
+use assists::utils::MergeBehaviour;
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct CompletionConfig {
    pub enable_postfix_completions: bool,
+    pub enable_experimental_completions: bool,
    pub add_call_parenthesis: bool,
    pub add_call_argument_snippets: bool,
    pub snippet_cap: Option<SnippetCap>,
+    pub merge: Option<MergeBehaviour>,
 }
 impl CompletionConfig {
@@ -27,9 +31,11 @@ impl Default for CompletionConfig {
    fn default() -> Self {
        CompletionConfig {
            enable_postfix_completions: true,
+            enable_experimental_completions: true,
            add_call_parenthesis: true,
            add_call_argument_snippets: true,
            snippet_cap: Some(SnippetCap { _private: () }),
+            merge: Some(MergeBehaviour::Full),
        }
    }
 }
diff --git a/crates/completion/src/context.rs b/crates/completion/src/context.rs
index bf70ee478..5cd11cf77 100644
--- a/crates/completion/src/context.rs
+++ b/crates/completion/src/context.rs
@@ -51,6 +51,7 @@ pub(crate) struct CompletionContext<'a> {
    /// If a name-binding or reference to a const in a pattern.
    /// Irrefutable patterns (like let) are excluded.
    pub(super) is_pat_binding_or_const: bool,
+    pub(super) is_irrefutable_let_pat_binding: bool,
    /// A single-indent path, like `foo`. `::foo` should not be considered a trivial path.
    pub(super) is_trivial_path: bool,
    /// If not a trivial path, the prefix (qualifier).
@@ -146,6 +147,7 @@ impl<'a> CompletionContext<'a> {
            active_parameter: ActiveParameter::at(db, position),
            is_param: false,
            is_pat_binding_or_const: false,
+            is_irrefutable_let_pat_binding: false,
            is_trivial_path: false,
            path_qual: None,
            after_if: false,
@@ -330,6 +332,7 @@ impl<'a> CompletionContext<'a> {
                        if pat.syntax().text_range().contains_range(bind_pat.syntax().text_range())
                        {
                            self.is_pat_binding_or_const = false;
+                            self.is_irrefutable_let_pat_binding = true;
                        }
                    }
                }
diff --git a/crates/completion/src/item.rs b/crates/completion/src/item.rs
index 6d1d085f4..b13c3f376 100644
--- a/crates/completion/src/item.rs
+++ b/crates/completion/src/item.rs
@@ -2,8 +2,9 @@
 use std::fmt;
-use hir::{Documentation, Mutability};
+use assists::utils::{insert_use, mod_path_to_ast, ImportScope, MergeBehaviour};
-use syntax::TextRange;
+use hir::{Documentation, ModPath, Mutability};
+use syntax::{algo, TextRange};
 use text_edit::TextEdit;
 use crate::config::SnippetCap;
@@ -31,6 +32,7 @@ pub struct CompletionItem {
    ///
    /// Typically, replaces `source_range` with new identifier.
    text_edit: TextEdit,
    insert_text_format: InsertTextFormat,
    /// What item (struct, function, etc) are we completing.
@@ -199,8 +201,10 @@ impl CompletionItem {
            trigger_call_info: None,
            score: None,
            ref_match: None,
+            import_data: None,
        }
    }
    /// What user sees in pop-up in the UI.
    pub fn label(&self) -> &str {
        &self.label
@@ -257,6 +261,7 @@ impl CompletionItem {
 pub(crate) struct Builder {
    source_range: TextRange,
    completion_kind: CompletionKind,
+    import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
    label: String,
    insert_text: Option<String>,
    insert_text_format: InsertTextFormat,
@@ -273,23 +278,50 @@ pub(crate) struct Builder {
 impl Builder {
    pub(crate) fn build(self) -> CompletionItem {
-        let label = self.label;
+        let mut label = self.label;
-        let text_edit = match self.text_edit {
+        let mut lookup = self.lookup;
+        let mut insert_text = self.insert_text;
+        let mut text_edits = TextEdit::builder();
+        if let Some((import_path, import_scope, merge_behaviour)) = self.import_data {
+            let import = mod_path_to_ast(&import_path);
+            let mut import_path_without_last_segment = import_path;
+            let _ = import_path_without_last_segment.segments.pop();
+            if !import_path_without_last_segment.segments.is_empty() {
+                if lookup.is_none() {
+                    lookup = Some(label.clone());
+                }
+                if insert_text.is_none() {
+                    insert_text = Some(label.clone());
+                }
+                label = format!("{}::{}", import_path_without_last_segment, label);
+            }
+            let rewriter = insert_use(&import_scope, import, merge_behaviour);
+            if let Some(old_ast) = rewriter.rewrite_root() {
+                algo::diff(&old_ast, &rewriter.rewrite(&old_ast)).into_text_edit(&mut text_edits);
+            }
+        }
+        let original_edit = match self.text_edit {
            Some(it) => it,
-            None => TextEdit::replace(
+            None => {
-                self.source_range,
+                TextEdit::replace(self.source_range, insert_text.unwrap_or_else(|| label.clone()))
-                self.insert_text.unwrap_or_else(|| label.clone()),
+            }
-            ),
        };
+        let mut resulting_edit = text_edits.finish();
+        resulting_edit.union(original_edit).expect("Failed to unite text edits");
        CompletionItem {
            source_range: self.source_range,
            label,
            insert_text_format: self.insert_text_format,
-            text_edit,
+            text_edit: resulting_edit,
            detail: self.detail,
            documentation: self.documentation,
-            lookup: self.lookup,
+            lookup,
            kind: self.kind,
            completion_kind: self.completion_kind,
            deprecated: self.deprecated.unwrap_or(false),
@@ -358,6 +390,13 @@ impl Builder {
        self.trigger_call_info = Some(true);
        self
    }
+    pub(crate) fn import_data(
+        mut self,
+        import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
+    ) -> Builder {
+        self.import_data = import_data;
+        self
+    }
    pub(crate) fn set_ref_match(
        mut self,
        ref_match: Option<(Mutability, CompletionScore)>,
diff --git a/crates/completion/src/lib.rs b/crates/completion/src/lib.rs
index cb6e0554e..aecc1378b 100644
--- a/crates/completion/src/lib.rs
+++ b/crates/completion/src/lib.rs
@@ -67,6 +67,13 @@ pub use crate::{
 //     fn test_name() {}
 // }
 // ```
+//
+// And experimental completions, enabled with the `rust-analyzer.completion.enableExperimental` setting.
+// This flag enables or disables:
+//
+// - Auto import: additional completion options with automatic `use` import and options from all project importable items, matched for the input
+//
+// Experimental completions might cause issues with performance and completion list look.
 /// Main entry point for completion. We run completion as a two-phase process.
 ///
diff --git a/crates/completion/src/render.rs b/crates/completion/src/render.rs
index 1fa02c375..bce02f577 100644
--- a/crates/completion/src/render.rs
+++ b/crates/completion/src/render.rs
@@ -9,7 +9,8 @@ pub(crate) mod type_alias;
 mod builder_ext;
-use hir::{Documentation, HasAttrs, HirDisplay, Mutability, ScopeDef, Type};
+use assists::utils::{ImportScope, MergeBehaviour};
+use hir::{Documentation, HasAttrs, HirDisplay, ModPath, Mutability, ScopeDef, Type};
 use ide_db::RootDatabase;
 use syntax::TextRange;
 use test_utils::mark;
@@ -42,7 +43,22 @@ pub(crate) fn render_resolution<'a>(
    local_name: String,
    resolution: &ScopeDef,
 ) -> Option<CompletionItem> {
-    Render::new(ctx).render_resolution(local_name, resolution)
+    Render::new(ctx).render_resolution(local_name, None, resolution)
+}
+pub(crate) fn render_resolution_with_import<'a>(
+    ctx: RenderContext<'a>,
+    import: ModPath,
+    import_scope: ImportScope,
+    merge_behaviour: Option<MergeBehaviour>,
+    resolution: &ScopeDef,
+) -> Option<CompletionItem> {
+    let local_name = import.segments.last()?.to_string();
+    Render::new(ctx).render_resolution(
+        local_name,
+        Some((import, import_scope, merge_behaviour)),
+        resolution,
+    )
 }
 /// Interface for data and methods required for items rendering.
@@ -131,8 +147,10 @@ impl<'a> Render<'a> {
    fn render_resolution(
        self,
        local_name: String,
+        import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
        resolution: &ScopeDef,
    ) -> Option<CompletionItem> {
+        let _p = profile::span("render_resolution");
        use hir::ModuleDef::*;
        let completion_kind = match resolution {
@@ -142,15 +160,15 @@ impl<'a> Render<'a> {
        let kind = match resolution {
            ScopeDef::ModuleDef(Function(func)) => {
-                let item = render_fn(self.ctx, Some(local_name), *func);
+                let item = render_fn(self.ctx, import_data, Some(local_name), *func);
                return Some(item);
            }
            ScopeDef::ModuleDef(EnumVariant(var)) => {
-                let item = render_enum_variant(self.ctx, Some(local_name), *var, None);
+                let item = render_enum_variant(self.ctx, import_data, Some(local_name), *var, None);
                return Some(item);
            }
            ScopeDef::MacroDef(mac) => {
-                let item = render_macro(self.ctx, local_name, *mac);
+                let item = render_macro(self.ctx, import_data, local_name, *mac);
                return item;
            }
@@ -175,6 +193,7 @@ impl<'a> Render<'a> {
                    local_name,
                )
                .kind(CompletionItemKind::UnresolvedReference)
+                .import_data(import_data)
                .build();
                return Some(item);
            }
@@ -227,7 +246,12 @@ impl<'a> Render<'a> {
            }
        }
-        let item = item.kind(kind).set_documentation(docs).set_ref_match(ref_match).build();
+        let item = item
+            .kind(kind)
+            .import_data(import_data)
+            .set_documentation(docs)
+            .set_ref_match(ref_match)
+            .build();
        Some(item)
    }
@@ -426,6 +450,28 @@ fn main() { let _: m::Spam = S<|> }
                        kind: Module,
                    },
                    CompletionItem {
+                        label: "m::Spam",
+                        source_range: 75..76,
+                        text_edit: TextEdit {
+                            indels: [
+                                Indel {
+                                    insert: "use m::Spam;",
+                                    delete: 0..0,
+                                },
+                                Indel {
+                                    insert: "\n\n",
+                                    delete: 0..0,
+                                },
+                                Indel {
+                                    insert: "Spam",
+                                    delete: 75..76,
+                                },
+                            ],
+                        },
+                        kind: Enum,
+                        lookup: "Spam",
+                    },
+                    CompletionItem {
                        label: "m::Spam::Foo",
                        source_range: 75..76,
                        delete: 75..76,
diff --git a/crates/completion/src/render/enum_variant.rs b/crates/completion/src/render/enum_variant.rs
index fd412ed0e..6070e9b1d 100644
--- a/crates/completion/src/render/enum_variant.rs
+++ b/crates/completion/src/render/enum_variant.rs
@@ -1,5 +1,6 @@
 //! Renderer for `enum` variants.
+use assists::utils::{ImportScope, MergeBehaviour};
 use hir::{HasAttrs, HirDisplay, ModPath, StructKind};
 use itertools::Itertools;
 use test_utils::mark;
@@ -11,11 +12,12 @@ use crate::{
 pub(crate) fn render_enum_variant<'a>(
    ctx: RenderContext<'a>,
+    import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
    local_name: Option<String>,
    variant: hir::EnumVariant,
    path: Option<ModPath>,
 ) -> CompletionItem {
-    EnumVariantRender::new(ctx, local_name, variant, path).render()
+    EnumVariantRender::new(ctx, local_name, variant, path).render(import_data)
 }
 #[derive(Debug)]
@@ -60,7 +62,10 @@ impl<'a> EnumVariantRender<'a> {
        }
    }
-    fn render(self) -> CompletionItem {
+    fn render(
+        self,
+        import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
+    ) -> CompletionItem {
        let mut builder = CompletionItem::new(
            CompletionKind::Reference,
            self.ctx.source_range(),
@@ -69,6 +74,7 @@ impl<'a> EnumVariantRender<'a> {
        .kind(CompletionItemKind::EnumVariant)
        .set_documentation(self.variant.docs(self.ctx.db()))
        .set_deprecated(self.ctx.is_deprecated(self.variant))
+        .import_data(import_data)
        .detail(self.detail());
        if self.variant_kind == StructKind::Tuple {
diff --git a/crates/completion/src/render/function.rs b/crates/completion/src/render/function.rs
index 4fa6eafd7..9dd5cd18c 100644
--- a/crates/completion/src/render/function.rs
+++ b/crates/completion/src/render/function.rs
@@ -1,6 +1,7 @@
 //! Renderer for function calls.
-use hir::{HasSource, Type};
+use assists::utils::{ImportScope, MergeBehaviour};
+use hir::{HasSource, ModPath, Type};
 use syntax::{ast::Fn, display::function_declaration};
 use crate::{
@@ -10,10 +11,11 @@ use crate::{
 pub(crate) fn render_fn<'a>(
    ctx: RenderContext<'a>,
+    import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
    local_name: Option<String>,
    fn_: hir::Function,
 ) -> CompletionItem {
-    FunctionRender::new(ctx, local_name, fn_).render()
+    FunctionRender::new(ctx, local_name, fn_).render(import_data)
 }
 #[derive(Debug)]
@@ -36,7 +38,10 @@ impl<'a> FunctionRender<'a> {
        FunctionRender { ctx, name, fn_, ast_node }
    }
-    fn render(self) -> CompletionItem {
+    fn render(
+        self,
+        import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
+    ) -> CompletionItem {
        let params = self.params();
        CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), self.name.clone())
            .kind(self.kind())
@@ -44,6 +49,7 @@ impl<'a> FunctionRender<'a> {
            .set_deprecated(self.ctx.is_deprecated(self.fn_))
            .detail(self.detail())
            .add_call_parens(self.ctx.completion, self.name, params)
+            .import_data(import_data)
            .build()
    }
diff --git a/crates/completion/src/render/macro_.rs b/crates/completion/src/render/macro_.rs
index 96be59cc3..fead59e41 100644
--- a/crates/completion/src/render/macro_.rs
+++ b/crates/completion/src/render/macro_.rs
@@ -1,6 +1,7 @@
 //! Renderer for macro invocations.
-use hir::{Documentation, HasSource};
+use assists::utils::{ImportScope, MergeBehaviour};
+use hir::{Documentation, HasSource, ModPath};
 use syntax::display::macro_label;
 use test_utils::mark;
@@ -11,10 +12,11 @@ use crate::{
 pub(crate) fn render_macro<'a>(
    ctx: RenderContext<'a>,
+    import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
    name: String,
    macro_: hir::MacroDef,
 ) -> Option<CompletionItem> {
-    MacroRender::new(ctx, name, macro_).render()
+    MacroRender::new(ctx, name, macro_).render(import_data)
 }
 #[derive(Debug)]
@@ -36,7 +38,10 @@ impl<'a> MacroRender<'a> {
        MacroRender { ctx, name, macro_, docs, bra, ket }
    }
-    fn render(&self) -> Option<CompletionItem> {
+    fn render(
+        &self,
+        import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
+    ) -> Option<CompletionItem> {
        // FIXME: Currently proc-macro do not have ast-node,
        // such that it does not have source
        if self.macro_.is_proc_macro() {
@@ -48,6 +53,7 @@ impl<'a> MacroRender<'a> {
                .kind(CompletionItemKind::Macro)
                .set_documentation(self.docs.clone())
                .set_deprecated(self.ctx.is_deprecated(self.macro_))
+                .import_data(import_data)
                .detail(self.detail());
        let needs_bang = self.needs_bang();
diff --git a/crates/flycheck/Cargo.toml b/crates/flycheck/Cargo.toml
index 44499bc79..3d9436d69 100644
--- a/crates/flycheck/Cargo.toml
+++ b/crates/flycheck/Cargo.toml
@@ -12,7 +12,7 @@ doctest = false
 [dependencies]
 crossbeam-channel = "0.5.0"
 log = "0.4.8"
-cargo_metadata = "0.12.0"
+cargo_metadata = "=0.12.0"
 serde_json = "1.0.48"
 jod-thread = "0.1.1"
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 30a5e4580..f06b5cd9f 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -110,15 +110,9 @@ impl Crate {
    pub fn query_external_importables(
        self,
        db: &dyn DefDatabase,
-        query: &str,
+        query: import_map::Query,
    ) -> impl Iterator<Item = Either<ModuleDef, MacroDef>> {
-        import_map::search_dependencies(
+        import_map::search_dependencies(db, self.into(), query).into_iter().map(|item| match item {
-            db,
-            self.into(),
-            import_map::Query::new(query).anchor_end().case_sensitive().limit(40),
-        )
-        .into_iter()
-        .map(|item| match item {
            ItemInNs::Types(mod_id) | ItemInNs::Values(mod_id) => Either::Left(mod_id.into()),
            ItemInNs::Macros(mac_id) => Either::Right(mac_id.into()),
        })
@@ -1426,11 +1420,11 @@ impl Type {
    pub fn normalize_trait_assoc_type(
        &self,
        db: &dyn HirDatabase,
-        r#trait: Trait,
+        trait_: Trait,
        args: &[Type],
        alias: TypeAlias,
    ) -> Option<Type> {
-        let subst = Substs::build_for_def(db, r#trait.id)
+        let subst = Substs::build_for_def(db, trait_.id)
            .push(self.ty.value.clone())
            .fill(args.iter().map(|t| t.ty.value.clone()))
            .build();
diff --git a/crates/hir/src/db.rs b/crates/hir/src/db.rs
index 07333c453..8c767b249 100644
--- a/crates/hir/src/db.rs
+++ b/crates/hir/src/db.rs
@@ -11,7 +11,7 @@ pub use hir_def::db::{
 };
 pub use hir_expand::db::{
    AstDatabase, AstDatabaseStorage, AstIdMapQuery, InternEagerExpansionQuery, InternMacroQuery,
-    MacroArgTextQuery, MacroDefQuery, MacroExpandQuery, ParseMacroQuery,
+    MacroArgTextQuery, MacroDefQuery, MacroExpandQuery, ParseMacroExpansionQuery,
 };
 pub use hir_ty::db::*;
diff --git a/crates/hir/src/diagnostics.rs b/crates/hir/src/diagnostics.rs
index c18c1c587..d9ad8db6f 100644
--- a/crates/hir/src/diagnostics.rs
+++ b/crates/hir/src/diagnostics.rs
@@ -1,6 +1,8 @@
 //! FIXME: write short doc here
 pub use hir_def::diagnostics::{InactiveCode, UnresolvedModule};
-pub use hir_expand::diagnostics::{Diagnostic, DiagnosticSink, DiagnosticSinkBuilder};
+pub use hir_expand::diagnostics::{
+    Diagnostic, DiagnosticCode, DiagnosticSink, DiagnosticSinkBuilder,
+};
 pub use hir_ty::diagnostics::{
    IncorrectCase, MismatchedArgCount, MissingFields, MissingMatchArms, MissingOkInTailExpr,
    NoSuchField,
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 0d184379f..93bdb4472 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -49,6 +49,7 @@ pub use hir_def::{
    builtin_type::BuiltinType,
    docs::Documentation,
    find_path::PrefixKind,
+    import_map,
    item_scope::ItemInNs,
    nameres::ModuleSource,
    path::{ModPath, PathKind},
@@ -56,8 +57,8 @@ pub use hir_def::{
    visibility::Visibility,
 };
 pub use hir_expand::{
-    name::known, name::AsName, name::Name, HirFileId, InFile, MacroCallId, MacroCallLoc,
+    name::known, name::AsName, name::Name, ExpandResult, HirFileId, InFile, MacroCallId,
-    /* FIXME */ MacroDefId, MacroFile, Origin,
+    MacroCallLoc, /* FIXME */ MacroDefId, MacroFile, Origin,
 };
 pub use hir_ty::display::HirDisplay;
diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs
index 1e24f29a8..c0f108848 100644
--- a/crates/hir_def/src/import_map.rs
+++ b/crates/hir_def/src/import_map.rs
@@ -7,7 +7,7 @@ use fst::{self, Streamer};
 use hir_expand::name::Name;
 use indexmap::{map::Entry, IndexMap};
 use itertools::Itertools;
-use rustc_hash::{FxHashMap, FxHasher};
+use rustc_hash::{FxHashMap, FxHashSet, FxHasher};
 use smallvec::SmallVec;
 use syntax::SmolStr;
@@ -225,6 +225,19 @@ fn cmp((_, lhs): &(&ItemInNs, &ImportInfo), (_, rhs): &(&ItemInNs, &ImportInfo))
    lhs_str.cmp(&rhs_str)
 }
+#[derive(Debug, Eq, PartialEq, Hash)]
+pub enum ImportKind {
+    Module,
+    Function,
+    Adt,
+    EnumVariant,
+    Const,
+    Static,
+    Trait,
+    TypeAlias,
+    BuiltinType,
+}
 #[derive(Debug)]
 pub struct Query {
    query: String,
@@ -232,6 +245,7 @@ pub struct Query {
    anchor_end: bool,
    case_sensitive: bool,
    limit: usize,
+    exclude_import_kinds: FxHashSet<ImportKind>,
 }
 impl Query {
@@ -242,6 +256,7 @@ impl Query {
            anchor_end: false,
            case_sensitive: false,
            limit: usize::max_value(),
+            exclude_import_kinds: FxHashSet::default(),
        }
    }
@@ -260,6 +275,12 @@ impl Query {
    pub fn case_sensitive(self) -> Self {
        Self { case_sensitive: true, ..self }
    }
+    /// Do not include imports of the specified kind in the search results.
+    pub fn exclude_import_kind(mut self, import_kind: ImportKind) -> Self {
+        self.exclude_import_kinds.insert(import_kind);
+        self
+    }
 }
 /// Searches dependencies of `krate` for an importable path matching `query`.
@@ -303,10 +324,17 @@ pub fn search_dependencies<'a>(
            // Add the items from this `ModPath` group. Those are all subsequent items in
            // `importables` whose paths match `path`.
-            let iter = importables.iter().copied().take_while(|item| {
+            let iter = importables
-                let item_path = &import_map.map[item].path;
+                .iter()
-                fst_path(item_path) == fst_path(path)
+                .copied()
-            });
+                .take_while(|item| {
+                    let item_path = &import_map.map[item].path;
+                    fst_path(item_path) == fst_path(path)
+                })
+                .filter(|&item| match item_import_kind(item) {
+                    Some(import_kind) => !query.exclude_import_kinds.contains(&import_kind),
+                    None => true,
+                });
            if query.case_sensitive {
                // FIXME: This does not do a subsequence match.
@@ -341,6 +369,20 @@ pub fn search_dependencies<'a>(
    res
 }
+fn item_import_kind(item: ItemInNs) -> Option<ImportKind> {
+    Some(match item.as_module_def_id()? {
+        ModuleDefId::ModuleId(_) => ImportKind::Module,
+        ModuleDefId::FunctionId(_) => ImportKind::Function,
+        ModuleDefId::AdtId(_) => ImportKind::Adt,
+        ModuleDefId::EnumVariantId(_) => ImportKind::EnumVariant,
+        ModuleDefId::ConstId(_) => ImportKind::Const,
+        ModuleDefId::StaticId(_) => ImportKind::Static,
+        ModuleDefId::TraitId(_) => ImportKind::Trait,
+        ModuleDefId::TypeAliasId(_) => ImportKind::TypeAlias,
+        ModuleDefId::BuiltinType(_) => ImportKind::BuiltinType,
+    })
+}
 #[cfg(test)]
 mod tests {
    use base_db::{fixture::WithFixture, SourceDatabase, Upcast};
@@ -758,4 +800,34 @@ mod tests {
            "#]],
        );
    }
+    #[test]
+    fn search_exclusions() {
+        let ra_fixture = r#"
+            //- /main.rs crate:main deps:dep
+            //- /dep.rs crate:dep
+            pub struct fmt;
+            pub struct FMT;
+        "#;
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("FMT"),
+            expect![[r#"
+                dep::fmt (t)
+                dep::fmt (v)
+                dep::FMT (t)
+                dep::FMT (v)
+            "#]],
+        );
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("FMT").exclude_import_kind(ImportKind::Adt),
+            expect![[r#""#]],
+        );
+    }
 }
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index eb41d324e..202a7dcb6 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -287,7 +287,7 @@ mod diagnostics {
    use hir_expand::diagnostics::DiagnosticSink;
    use hir_expand::hygiene::Hygiene;
    use hir_expand::InFile;
-    use syntax::{ast, AstPtr, SyntaxNodePtr};
+    use syntax::{ast, AstPtr};
    use crate::path::ModPath;
    use crate::{db::DefDatabase, diagnostics::*, nameres::LocalModuleId, AstId};
@@ -300,7 +300,7 @@ mod diagnostics {
        UnresolvedImport { ast: AstId<ast::Use>, index: usize },
-        UnconfiguredCode { ast: InFile<SyntaxNodePtr>, cfg: CfgExpr, opts: CfgOptions },
+        UnconfiguredCode { ast: AstId<ast::Item>, cfg: CfgExpr, opts: CfgOptions },
    }
    #[derive(Debug, PartialEq, Eq)]
@@ -341,7 +341,7 @@ mod diagnostics {
        pub(super) fn unconfigured_code(
            container: LocalModuleId,
-            ast: InFile<SyntaxNodePtr>,
+            ast: AstId<ast::Item>,
            cfg: CfgExpr,
            opts: CfgOptions,
        ) -> Self {
@@ -399,9 +399,10 @@ mod diagnostics {
                }
                DiagnosticKind::UnconfiguredCode { ast, cfg, opts } => {
+                    let item = ast.to_node(db.upcast());
                    sink.push(InactiveCode {
                        file: ast.file_id,
-                        node: ast.value.clone(),
+                        node: AstPtr::new(&item).into(),
                        cfg: cfg.clone(),
                        opts: opts.clone(),
                    });
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 386287518..5ed9073e0 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -1336,13 +1336,11 @@ impl ModCollector<'_, '_> {
    fn emit_unconfigured_diagnostic(&mut self, item: ModItem, cfg: &CfgExpr) {
        let ast_id = item.ast_id(self.item_tree);
-        let id_map = self.def_collector.db.ast_id_map(self.file_id);
-        let syntax_ptr = id_map.get(ast_id).syntax_node_ptr();
-        let ast_node = InFile::new(self.file_id, syntax_ptr);
+        let ast_id = InFile::new(self.file_id, ast_id);
        self.def_collector.def_map.diagnostics.push(DefDiagnostic::unconfigured_code(
            self.module_id,
-            ast_node,
+            ast_id,
            cfg.clone(),
            self.def_collector.cfg_options.clone(),
        ));
diff --git a/crates/hir_def/src/nameres/tests/incremental.rs b/crates/hir_def/src/nameres/tests/incremental.rs
index cfbc62cc4..8981fa7c9 100644
--- a/crates/hir_def/src/nameres/tests/incremental.rs
+++ b/crates/hir_def/src/nameres/tests/incremental.rs
@@ -38,6 +38,9 @@ fn typing_inside_a_function_should_not_invalidate_def_map() {
        fn foo() -> i32 {
            1 + 1
        }
+        #[cfg(never)]
+        fn no() {}
        //- /foo/mod.rs
        pub mod bar;
@@ -53,6 +56,9 @@ fn typing_inside_a_function_should_not_invalidate_def_map() {
        use E::*;
        fn foo() -> i32 { 92 }
+        #[cfg(never)]
+        fn no() {}
        ",
    );
 }
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index ade57ac1b..46ebdbc74 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -75,9 +75,11 @@ pub trait AstDatabase: SourceDatabase {
    #[salsa::transparent]
    fn macro_arg(&self, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>>;
    fn macro_def(&self, id: MacroDefId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>>;
-    fn parse_macro(&self, macro_file: MacroFile)
+    fn parse_macro_expansion(
-        -> Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>;
+        &self,
-    fn macro_expand(&self, macro_call: MacroCallId) -> (Option<Arc<tt::Subtree>>, Option<String>);
+        macro_file: MacroFile,
+    ) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>>;
+    fn macro_expand(&self, macro_call: MacroCallId) -> ExpandResult<Option<Arc<tt::Subtree>>>;
    #[salsa::interned]
    fn intern_eager_expansion(&self, eager: EagerCallLoc) -> EagerMacroId;
@@ -102,23 +104,20 @@ pub fn expand_hypothetical(
    let token_id = tmap_1.token_by_range(range)?;
    let macro_def = expander(db, actual_macro_call)?;
    let (node, tmap_2) =
-        parse_macro_with_arg(db, macro_file, Some(std::sync::Arc::new((tt, tmap_1))))?;
+        parse_macro_with_arg(db, macro_file, Some(std::sync::Arc::new((tt, tmap_1)))).value?;
    let token_id = macro_def.0.map_id_down(token_id);
    let range = tmap_2.range_by_token(token_id)?.by_kind(token_to_map.kind())?;
    let token = syntax::algo::find_covering_element(&node.syntax_node(), range).into_token()?;
    Some((node.syntax_node(), token))
 }
-pub(crate) fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
+fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
    let map =
        db.parse_or_expand(file_id).map_or_else(AstIdMap::default, |it| AstIdMap::from_source(&it));
    Arc::new(map)
 }
-pub(crate) fn macro_def(
+fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
-    db: &dyn AstDatabase,
-    id: MacroDefId,
-) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
    match id.kind {
        MacroDefKind::Declarative => {
            let macro_call = id.ast_id?.to_node(db);
@@ -149,7 +148,7 @@ pub(crate) fn macro_def(
    }
 }
-pub(crate) fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
+fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
    let id = match id {
        MacroCallId::LazyMacro(id) => id,
        MacroCallId::EagerMacro(_id) => {
@@ -162,19 +161,13 @@ pub(crate) fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<Gr
    Some(arg.green().clone())
 }
-pub(crate) fn macro_arg(
+fn macro_arg(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>> {
-    db: &dyn AstDatabase,
-    id: MacroCallId,
-) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>> {
    let arg = db.macro_arg_text(id)?;
    let (tt, tmap) = mbe::syntax_node_to_token_tree(&SyntaxNode::new_root(arg))?;
    Some(Arc::new((tt, tmap)))
 }
-pub(crate) fn macro_expand(
+fn macro_expand(db: &dyn AstDatabase, id: MacroCallId) -> ExpandResult<Option<Arc<tt::Subtree>>> {
-    db: &dyn AstDatabase,
-    id: MacroCallId,
-) -> (Option<Arc<tt::Subtree>>, Option<String>) {
    macro_expand_with_arg(db, id, None)
 }
@@ -195,17 +188,19 @@ fn macro_expand_with_arg(
    db: &dyn AstDatabase,
    id: MacroCallId,
    arg: Option<Arc<(tt::Subtree, mbe::TokenMap)>>,
-) -> (Option<Arc<tt::Subtree>>, Option<String>) {
+) -> ExpandResult<Option<Arc<tt::Subtree>>> {
    let lazy_id = match id {
        MacroCallId::LazyMacro(id) => id,
        MacroCallId::EagerMacro(id) => {
            if arg.is_some() {
-                return (
+                return ExpandResult::str_err(
-                    None,
+                    "hypothetical macro expansion not implemented for eager macro".to_owned(),
-                    Some("hypothetical macro expansion not implemented for eager macro".to_owned()),
                );
            } else {
-                return (Some(db.lookup_intern_eager_expansion(id).subtree), None);
+                return ExpandResult {
+                    value: Some(db.lookup_intern_eager_expansion(id).subtree),
+                    err: None,
+                };
            }
        }
    };
@@ -213,23 +208,27 @@ fn macro_expand_with_arg(
    let loc = db.lookup_intern_macro(lazy_id);
    let macro_arg = match arg.or_else(|| db.macro_arg(id)) {
        Some(it) => it,
-        None => return (None, Some("Fail to args in to tt::TokenTree".into())),
+        None => return ExpandResult::str_err("Fail to args in to tt::TokenTree".into()),
    };
    let macro_rules = match db.macro_def(loc.def) {
        Some(it) => it,
-        None => return (None, Some("Fail to find macro definition".into())),
+        None => return ExpandResult::str_err("Fail to find macro definition".into()),
    };
-    let ExpandResult(tt, err) = macro_rules.0.expand(db, lazy_id, &macro_arg.0);
+    let ExpandResult { value: tt, err } = macro_rules.0.expand(db, lazy_id, &macro_arg.0);
    // Set a hard limit for the expanded tt
    let count = tt.count();
    if count > 262144 {
-        return (None, Some(format!("Total tokens count exceed limit : count = {}", count)));
+        return ExpandResult::str_err(format!(
+            "Total tokens count exceed limit : count = {}",
+            count
+        ));
    }
-    (Some(Arc::new(tt)), err.map(|e| format!("{:?}", e)))
+    ExpandResult { value: Some(Arc::new(tt)), err }
 }
-pub(crate) fn expand_proc_macro(
+fn expand_proc_macro(
    db: &dyn AstDatabase,
    id: MacroCallId,
 ) -> Result<tt::Subtree, mbe::ExpandError> {
@@ -256,36 +255,36 @@ pub(crate) fn expand_proc_macro(
    expander.expand(db, lazy_id, &macro_arg.0)
 }
-pub(crate) fn parse_or_expand(db: &dyn AstDatabase, file_id: HirFileId) -> Option<SyntaxNode> {
+fn parse_or_expand(db: &dyn AstDatabase, file_id: HirFileId) -> Option<SyntaxNode> {
    match file_id.0 {
        HirFileIdRepr::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()),
        HirFileIdRepr::MacroFile(macro_file) => {
-            db.parse_macro(macro_file).map(|(it, _)| it.syntax_node())
+            db.parse_macro_expansion(macro_file).value.map(|(it, _)| it.syntax_node())
        }
    }
 }
-pub(crate) fn parse_macro(
+fn parse_macro_expansion(
    db: &dyn AstDatabase,
    macro_file: MacroFile,
-) -> Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)> {
+) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>> {
    parse_macro_with_arg(db, macro_file, None)
 }
-pub fn parse_macro_with_arg(
+fn parse_macro_with_arg(
    db: &dyn AstDatabase,
    macro_file: MacroFile,
    arg: Option<Arc<(tt::Subtree, mbe::TokenMap)>>,
-) -> Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)> {
+) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>> {
    let _p = profile::span("parse_macro_query");
    let macro_call_id = macro_file.macro_call_id;
-    let (tt, err) = if let Some(arg) = arg {
+    let result = if let Some(arg) = arg {
        macro_expand_with_arg(db, macro_call_id, Some(arg))
    } else {
        db.macro_expand(macro_call_id)
    };
-    if let Some(err) = &err {
+    if let Some(err) = &result.err {
        // Note:
        // The final goal we would like to make all parse_macro success,
        // such that the following log will not call anyway.
@@ -303,40 +302,50 @@ pub fn parse_macro_with_arg(
                .join("\n");
                log::warn!(
-                    "fail on macro_parse: (reason: {} macro_call: {:#}) parents: {}",
+                    "fail on macro_parse: (reason: {:?} macro_call: {:#}) parents: {}",
                    err,
                    node.value,
                    parents
                );
            }
            _ => {
-                log::warn!("fail on macro_parse: (reason: {})", err);
+                log::warn!("fail on macro_parse: (reason: {:?})", err);
            }
        }
+    }
+    let tt = match result.value {
+        Some(tt) => tt,
+        None => return ExpandResult { value: None, err: result.err },
    };
-    let tt = tt?;
    let fragment_kind = to_fragment_kind(db, macro_call_id);
-    let (parse, rev_token_map) = mbe::token_tree_to_syntax_node(&tt, fragment_kind).ok()?;
+    let (parse, rev_token_map) = match mbe::token_tree_to_syntax_node(&tt, fragment_kind) {
+        Ok(it) => it,
+        Err(err) => {
+            return ExpandResult::only_err(err);
+        }
+    };
-    if err.is_none() {
+    match result.err {
-        Some((parse, Arc::new(rev_token_map)))
+        Some(err) => {
-    } else {
+            // Safety check for recursive identity macro.
-        // FIXME:
+            let node = parse.syntax_node();
-        // In future, we should propagate the actual error with recovery information
+            let file: HirFileId = macro_file.into();
-        // instead of ignore the error here.
+            let call_node = match file.call_node(db) {
+                Some(it) => it,
-        // Safe check for recurisve identity macro
+                None => {
-        let node = parse.syntax_node();
+                    return ExpandResult::only_err(err);
-        let file: HirFileId = macro_file.into();
+                }
-        let call_node = file.call_node(db)?;
+            };
-        if !diff(&node, &call_node.value).is_empty() {
+            if !diff(&node, &call_node.value).is_empty() {
-            Some((parse, Arc::new(rev_token_map)))
+                ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: Some(err) }
-        } else {
+            } else {
-            None
+                return ExpandResult::only_err(err);
+            }
        }
+        None => ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: None },
    }
 }
diff --git a/crates/hir_expand/src/diagnostics.rs b/crates/hir_expand/src/diagnostics.rs
index 78ccc212c..1043c6aeb 100644
--- a/crates/hir_expand/src/diagnostics.rs
+++ b/crates/hir_expand/src/diagnostics.rs
@@ -20,7 +20,7 @@ use syntax::SyntaxNodePtr;
 use crate::InFile;
-#[derive(Copy, Clone, PartialEq)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 pub struct DiagnosticCode(pub &'static str);
 impl DiagnosticCode {
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 17f1178ed..d5ba691b7 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -15,6 +15,8 @@ pub mod proc_macro;
 pub mod quote;
 pub mod eager;
+pub use mbe::{ExpandError, ExpandResult};
 use std::hash::Hash;
 use std::sync::Arc;
@@ -144,7 +146,7 @@ impl HirFileId {
                let def_tt = loc.def.ast_id?.to_node(db).token_tree()?;
                let macro_def = db.macro_def(loc.def)?;
-                let (parse, exp_map) = db.parse_macro(macro_file)?;
+                let (parse, exp_map) = db.parse_macro_expansion(macro_file).value?;
                let macro_arg = db.macro_arg(macro_file.macro_call_id)?;
                Some(ExpansionInfo {
diff --git a/crates/hir_ty/src/diagnostics/match_check.rs b/crates/hir_ty/src/diagnostics/match_check.rs
index 5bd03f2ac..62c329731 100644
--- a/crates/hir_ty/src/diagnostics/match_check.rs
+++ b/crates/hir_ty/src/diagnostics/match_check.rs
@@ -216,14 +216,14 @@
 //!   U(P, p) := U(P, (r_1, p_2, .., p_n))
 //!            || U(P, (r_2, p_2, .., p_n))
 //!   ```
-use std::sync::Arc;
+use std::{iter, sync::Arc};
 use arena::Idx;
 use hir_def::{
    adt::VariantData,
    body::Body,
    expr::{Expr, Literal, Pat, PatId},
-    AdtId, EnumVariantId, VariantId,
+    AdtId, EnumVariantId, StructId, VariantId,
 };
 use smallvec::{smallvec, SmallVec};
@@ -366,16 +366,17 @@ impl PatStack {
        let head_pat = head.as_pat(cx);
        let result = match (head_pat, constructor) {
-            (Pat::Tuple { args: ref pat_ids, ellipsis }, Constructor::Tuple { arity: _ }) => {
+            (Pat::Tuple { args: pat_ids, ellipsis }, &Constructor::Tuple { arity }) => {
-                if ellipsis.is_some() {
+                if let Some(ellipsis) = ellipsis {
-                    // If there are ellipsis here, we should add the correct number of
+                    let (pre, post) = pat_ids.split_at(ellipsis);
-                    // Pat::Wild patterns to `pat_ids`. We should be able to use the
+                    let n_wild_pats = arity.saturating_sub(pat_ids.len());
-                    // constructors arity for this, but at the time of writing we aren't
+                    let pre_iter = pre.iter().map(Into::into);
-                    // correctly calculating this arity when ellipsis are present.
+                    let wildcards = iter::repeat(PatIdOrWild::Wild).take(n_wild_pats);
-                    return Err(MatchCheckErr::NotImplemented);
+                    let post_iter = post.iter().map(Into::into);
+                    Some(self.replace_head_with(pre_iter.chain(wildcards).chain(post_iter)))
+                } else {
+                    Some(self.replace_head_with(pat_ids.iter()))
                }
-                Some(self.replace_head_with(pat_ids.iter()))
            }
            (Pat::Lit(lit_expr), Constructor::Bool(constructor_val)) => {
                match cx.body.exprs[lit_expr] {
@@ -390,21 +391,28 @@ impl PatStack {
                }
            }
            (Pat::Wild, constructor) => Some(self.expand_wildcard(cx, constructor)?),
-            (Pat::Path(_), Constructor::Enum(constructor)) => {
+            (Pat::Path(_), constructor) => {
                // unit enum variants become `Pat::Path`
                let pat_id = head.as_id().expect("we know this isn't a wild");
-                if !enum_variant_matches(cx, pat_id, *constructor) {
+                let variant_id: VariantId = match constructor {
+                    &Constructor::Enum(e) => e.into(),
+                    &Constructor::Struct(s) => s.into(),
+                    _ => return Err(MatchCheckErr::NotImplemented),
+                };
+                if Some(variant_id) != cx.infer.variant_resolution_for_pat(pat_id) {
                    None
                } else {
                    Some(self.to_tail())
                }
            }
-            (
+            (Pat::TupleStruct { args: ref pat_ids, ellipsis, .. }, constructor) => {
-                Pat::TupleStruct { args: ref pat_ids, ellipsis, .. },
-                Constructor::Enum(enum_constructor),
-            ) => {
                let pat_id = head.as_id().expect("we know this isn't a wild");
-                if !enum_variant_matches(cx, pat_id, *enum_constructor) {
+                let variant_id: VariantId = match constructor {
+                    &Constructor::Enum(e) => e.into(),
+                    &Constructor::Struct(s) => s.into(),
+                    _ => return Err(MatchCheckErr::MalformedMatchArm),
+                };
+                if Some(variant_id) != cx.infer.variant_resolution_for_pat(pat_id) {
                    None
                } else {
                    let constructor_arity = constructor.arity(cx)?;
@@ -442,12 +450,22 @@ impl PatStack {
                    }
                }
            }
-            (Pat::Record { args: ref arg_patterns, .. }, Constructor::Enum(e)) => {
+            (Pat::Record { args: ref arg_patterns, .. }, constructor) => {
                let pat_id = head.as_id().expect("we know this isn't a wild");
-                if !enum_variant_matches(cx, pat_id, *e) {
+                let (variant_id, variant_data) = match constructor {
+                    &Constructor::Enum(e) => (
+                        e.into(),
+                        cx.db.enum_data(e.parent).variants[e.local_id].variant_data.clone(),
+                    ),
+                    &Constructor::Struct(s) => {
+                        (s.into(), cx.db.struct_data(s).variant_data.clone())
+                    }
+                    _ => return Err(MatchCheckErr::MalformedMatchArm),
+                };
+                if Some(variant_id) != cx.infer.variant_resolution_for_pat(pat_id) {
                    None
                } else {
-                    match cx.db.enum_data(e.parent).variants[e.local_id].variant_data.as_ref() {
+                    match variant_data.as_ref() {
                        VariantData::Record(struct_field_arena) => {
                            // Here we treat any missing fields in the record as the wild pattern, as
                            // if the record has ellipsis. We want to do this here even if the
@@ -726,6 +744,7 @@ enum Constructor {
    Bool(bool),
    Tuple { arity: usize },
    Enum(EnumVariantId),
+    Struct(StructId),
 }
 impl Constructor {
@@ -740,6 +759,11 @@ impl Constructor {
                    VariantData::Unit => 0,
                }
            }
+            &Constructor::Struct(s) => match cx.db.struct_data(s).variant_data.as_ref() {
+                VariantData::Tuple(struct_field_data) => struct_field_data.len(),
+                VariantData::Record(struct_field_data) => struct_field_data.len(),
+                VariantData::Unit => 0,
+            },
        };
        Ok(arity)
@@ -748,7 +772,7 @@ impl Constructor {
    fn all_constructors(&self, cx: &MatchCheckCtx) -> Vec<Constructor> {
        match self {
            Constructor::Bool(_) => vec![Constructor::Bool(true), Constructor::Bool(false)],
-            Constructor::Tuple { .. } => vec![*self],
+            Constructor::Tuple { .. } | Constructor::Struct(_) => vec![*self],
            Constructor::Enum(e) => cx
                .db
                .enum_data(e.parent)
@@ -767,10 +791,11 @@ impl Constructor {
 fn pat_constructor(cx: &MatchCheckCtx, pat: PatIdOrWild) -> MatchCheckResult<Option<Constructor>> {
    let res = match pat.as_pat(cx) {
        Pat::Wild => None,
-        // FIXME somehow create the Tuple constructor with the proper arity. If there are
+        Pat::Tuple { .. } => {
-        // ellipsis, the arity is not equal to the number of patterns.
+            let pat_id = pat.as_id().expect("we already know this pattern is not a wild");
-        Pat::Tuple { args: pats, ellipsis } if ellipsis.is_none() => {
+            Some(Constructor::Tuple {
-            Some(Constructor::Tuple { arity: pats.len() })
+                arity: cx.infer.type_of_pat[pat_id].as_tuple().ok_or(MatchCheckErr::Unknown)?.len(),
+            })
        }
        Pat::Lit(lit_expr) => match cx.body.exprs[lit_expr] {
            Expr::Literal(Literal::Bool(val)) => Some(Constructor::Bool(val)),
@@ -784,6 +809,7 @@ fn pat_constructor(cx: &MatchCheckCtx, pat: PatIdOrWild) -> MatchCheckResult<Opt
                VariantId::EnumVariantId(enum_variant_id) => {
                    Some(Constructor::Enum(enum_variant_id))
                }
+                VariantId::StructId(struct_id) => Some(Constructor::Struct(struct_id)),
                _ => return Err(MatchCheckErr::NotImplemented),
            }
        }
@@ -828,13 +854,13 @@ fn all_constructors_covered(
            false
        }),
+        &Constructor::Struct(s) => used_constructors.iter().any(|constructor| match constructor {
+            &Constructor::Struct(sid) => sid == s,
+            _ => false,
+        }),
    }
 }
-fn enum_variant_matches(cx: &MatchCheckCtx, pat_id: PatId, enum_variant_id: EnumVariantId) -> bool {
-    Some(enum_variant_id.into()) == cx.infer.variant_resolution_for_pat(pat_id)
-}
 #[cfg(test)]
 mod tests {
    use crate::diagnostics::tests::check_diagnostics;
@@ -846,8 +872,8 @@ mod tests {
 fn main() {
    match () { }
        //^^ Missing match arm
-   match (()) { }
+    match (()) { }
-       //^^^^ Missing match arm
+        //^^^^ Missing match arm
    match () { _ => (), }
    match () { () => (), }
@@ -1352,6 +1378,123 @@ fn main() {
        );
    }
+    #[test]
+    fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
+        check_diagnostics(
+            r#"
+fn main() {
+    match (false, true, false) {
+        //^^^^^^^^^^^^^^^^^^^^ Missing match arm
+        (false, ..) => (),
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
+        check_diagnostics(
+            r#"
+fn main() {
+    match (false, true, false) {
+        //^^^^^^^^^^^^^^^^^^^^ Missing match arm
+        (.., false) => (),
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn tuple_of_bools_with_ellipsis_in_middle_missing_arm() {
+        check_diagnostics(
+            r#"
+fn main() {
+    match (false, true, false) {
+        //^^^^^^^^^^^^^^^^^^^^ Missing match arm
+        (true, .., false) => (),
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn record_struct() {
+        check_diagnostics(
+            r#"struct Foo { a: bool }
+fn main(f: Foo) {
+    match f {}
+        //^ Missing match arm
+    match f { Foo { a: true } => () }
+        //^ Missing match arm
+    match &f { Foo { a: true } => () }
+        //^^ Missing match arm
+    match f { Foo { a: _ } => () }
+    match f {
+        Foo { a: true } => (),
+        Foo { a: false } => (),
+    }
+    match &f {
+        Foo { a: true } => (),
+        Foo { a: false } => (),
+    }
+}
+"#,
+        );
+    }
+    #[test]
+    fn tuple_struct() {
+        check_diagnostics(
+            r#"struct Foo(bool);
+fn main(f: Foo) {
+    match f {}
+        //^ Missing match arm
+    match f { Foo(true) => () }
+        //^ Missing match arm
+    match f {
+        Foo(true) => (),
+        Foo(false) => (),
+    }
+}
+"#,
+        );
+    }
+    #[test]
+    fn unit_struct() {
+        check_diagnostics(
+            r#"struct Foo;
+fn main(f: Foo) {
+    match f {}
+        //^ Missing match arm
+    match f { Foo => () }
+}
+"#,
+        );
+    }
+    #[test]
+    fn record_struct_ellipsis() {
+        check_diagnostics(
+            r#"struct Foo { foo: bool, bar: bool }
+fn main(f: Foo) {
+    match f { Foo { foo: true, .. } => () }
+        //^ Missing match arm
+    match f {
+        //^ Missing match arm
+        Foo { foo: true, .. } => (),
+        Foo { bar: false, .. } => ()
+    }
+    match f { Foo { .. } => () }
+    match f {
+        Foo { foo: true, .. } => (),
+        Foo { foo: false, .. } => ()
+    }
+}
+"#,
+        );
+    }
    mod false_negatives {
        //! The implementation of match checking here is a work in progress. As we roll this out, we
        //! prefer false negatives to false positives (ideally there would be no false positives). This
@@ -1393,46 +1536,5 @@ fn main() {
 "#,
            );
        }
-        #[test]
-        fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
-            // We don't currently handle tuple patterns with ellipsis.
-            check_diagnostics(
-                r#"
-fn main() {
-    match (false, true, false) {
-        (false, ..) => (),
-    }
-}
-"#,
-            );
-        }
-        #[test]
-        fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
-            // We don't currently handle tuple patterns with ellipsis.
-            check_diagnostics(
-                r#"
-fn main() {
-    match (false, true, false) {
-        (.., false) => (),
-    }
-}
-"#,
-            );
-        }
-        #[test]
-        fn struct_missing_arm() {
-            // We don't currently handle structs.
-            check_diagnostics(
-                r#"
-struct Foo { a: bool }
-fn main(f: Foo) {
-    match f { Foo { a: true } => () }
-}
-"#,
-            );
-        }
    }
 }
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index cde2ab82b..b70ec55eb 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -23,6 +23,7 @@ impl<'a> InferenceContext<'a> {
        expected: &Ty,
        default_bm: BindingMode,
        id: PatId,
+        ellipsis: Option<usize>,
    ) -> Ty {
        let (ty, def) = self.resolve_variant(path);
        let var_data = def.map(|it| variant_data(self.db.upcast(), it));
@@ -34,8 +35,15 @@ impl<'a> InferenceContext<'a> {
        let substs = ty.substs().unwrap_or_else(Substs::empty);
        let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();
+        let (pre, post) = match ellipsis {
+            Some(idx) => subpats.split_at(idx),
+            None => (&subpats[..], &[][..]),
+        };
+        let post_idx_offset = field_tys.iter().count() - post.len();
-        for (i, &subpat) in subpats.iter().enumerate() {
+        let pre_iter = pre.iter().enumerate();
+        let post_iter = (post_idx_offset..).zip(post.iter());
+        for (i, &subpat) in pre_iter.chain(post_iter) {
            let expected_ty = var_data
                .as_ref()
                .and_then(|d| d.field(&Name::new_tuple_field(i)))
@@ -111,20 +119,29 @@ impl<'a> InferenceContext<'a> {
        let expected = expected;
        let ty = match &body[pat] {
-            Pat::Tuple { ref args, .. } => {
+            &Pat::Tuple { ref args, ellipsis } => {
                let expectations = match expected.as_tuple() {
                    Some(parameters) => &*parameters.0,
                    _ => &[],
                };
-                let expectations_iter = expectations.iter().chain(repeat(&Ty::Unknown));
-                let inner_tys = args
+                let (pre, post) = match ellipsis {
-                    .iter()
+                    Some(idx) => args.split_at(idx),
-                    .zip(expectations_iter)
+                    None => (&args[..], &[][..]),
-                    .map(|(&pat, ty)| self.infer_pat(pat, ty, default_bm))
+                };
-                    .collect();
+                let n_uncovered_patterns = expectations.len().saturating_sub(args.len());
+                let mut expectations_iter = expectations.iter().chain(repeat(&Ty::Unknown));
+                let mut infer_pat = |(&pat, ty)| self.infer_pat(pat, ty, default_bm);
+                let mut inner_tys = Vec::with_capacity(n_uncovered_patterns + args.len());
+                inner_tys.extend(pre.iter().zip(expectations_iter.by_ref()).map(&mut infer_pat));
+                inner_tys.extend(expectations_iter.by_ref().take(n_uncovered_patterns).cloned());
+                inner_tys.extend(post.iter().zip(expectations_iter).map(infer_pat));
-                Ty::apply(TypeCtor::Tuple { cardinality: args.len() as u16 }, Substs(inner_tys))
+                Ty::apply(
+                    TypeCtor::Tuple { cardinality: inner_tys.len() as u16 },
+                    Substs(inner_tys.into()),
+                )
            }
            Pat::Or(ref pats) => {
                if let Some((first_pat, rest)) = pats.split_first() {
@@ -150,9 +167,14 @@ impl<'a> InferenceContext<'a> {
                let subty = self.infer_pat(*pat, expectation, default_bm);
                Ty::apply_one(TypeCtor::Ref(*mutability), subty)
            }
-            Pat::TupleStruct { path: p, args: subpats, .. } => {
+            Pat::TupleStruct { path: p, args: subpats, ellipsis } => self.infer_tuple_struct_pat(
-                self.infer_tuple_struct_pat(p.as_ref(), subpats, expected, default_bm, pat)
+                p.as_ref(),
-            }
+                subpats,
+                expected,
+                default_bm,
+                pat,
+                *ellipsis,
+            ),
            Pat::Record { path: p, args: fields, ellipsis: _ } => {
                self.infer_record_pat(p.as_ref(), fields, expected, default_bm, pat)
            }
diff --git a/crates/hir_ty/src/tests/patterns.rs b/crates/hir_ty/src/tests/patterns.rs
index 6a965ac4f..5a5f48fd0 100644
--- a/crates/hir_ty/src/tests/patterns.rs
+++ b/crates/hir_ty/src/tests/patterns.rs
@@ -679,3 +679,98 @@ fn box_pattern() {
        "#]],
    );
 }
+#[test]
+fn tuple_ellipsis_pattern() {
+    check_infer(
+        r#"
+fn foo(tuple: (u8, i16, f32)) {
+    match tuple {
+        (.., b, c) => {},
+        (a, .., c) => {},
+        (a, b, ..) => {},
+        (a, b) => {/*too short*/}
+        (a, b, c, d) => {/*too long*/}
+        _ => {}
+    }
+}"#,
+        expect![[r#"
+            7..12 'tuple': (u8, i16, f32)
+            30..224 '{     ...   } }': ()
+            36..222 'match ...     }': ()
+            42..47 'tuple': (u8, i16, f32)
+            58..68 '(.., b, c)': (u8, i16, f32)
+            63..64 'b': i16
+            66..67 'c': f32
+            72..74 '{}': ()
+            84..94 '(a, .., c)': (u8, i16, f32)
+            85..86 'a': u8
+            92..93 'c': f32
+            98..100 '{}': ()
+            110..120 '(a, b, ..)': (u8, i16, f32)
+            111..112 'a': u8
+            114..115 'b': i16
+            124..126 '{}': ()
+            136..142 '(a, b)': (u8, i16, f32)
+            137..138 'a': u8
+            140..141 'b': i16
+            146..161 '{/*too short*/}': ()
+            170..182 '(a, b, c, d)': (u8, i16, f32, {unknown})
+            171..172 'a': u8
+            174..175 'b': i16
+            177..178 'c': f32
+            180..181 'd': {unknown}
+            186..200 '{/*too long*/}': ()
+            209..210 '_': (u8, i16, f32)
+            214..216 '{}': ()
+        "#]],
+    );
+}
+#[test]
+fn tuple_struct_ellipsis_pattern() {
+    check_infer(
+        r#"
+struct Tuple(u8, i16, f32);
+fn foo(tuple: Tuple) {
+    match tuple {
+        Tuple(.., b, c) => {},
+        Tuple(a, .., c) => {},
+        Tuple(a, b, ..) => {},
+        Tuple(a, b) => {/*too short*/}
+        Tuple(a, b, c, d) => {/*too long*/}
+        _ => {}
+    }
+}"#,
+        expect![[r#"
+            35..40 'tuple': Tuple
+            49..268 '{     ...   } }': ()
+            55..266 'match ...     }': ()
+            61..66 'tuple': Tuple
+            77..92 'Tuple(.., b, c)': Tuple
+            87..88 'b': i16
+            90..91 'c': f32
+            96..98 '{}': ()
+            108..123 'Tuple(a, .., c)': Tuple
+            114..115 'a': u8
+            121..122 'c': f32
+            127..129 '{}': ()
+            139..154 'Tuple(a, b, ..)': Tuple
+            145..146 'a': u8
+            148..149 'b': i16
+            158..160 '{}': ()
+            170..181 'Tuple(a, b)': Tuple
+            176..177 'a': u8
+            179..180 'b': i16
+            185..200 '{/*too short*/}': ()
+            209..226 'Tuple(... c, d)': Tuple
+            215..216 'a': u8
+            218..219 'b': i16
+            221..222 'c': f32
+            224..225 'd': {unknown}
+            230..244 '{/*too long*/}': ()
+            253..254 '_': Tuple
+            258..260 '{}': ()
+        "#]],
+    );
+}
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index 1c7f02763..3df73ed4f 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/