3 files changed, 287 insertions, 26 deletions

diff --git a/crates/ra_assists/src/assists/add_explicit_type.rs b/crates/ra_assists/src/assists/add_explicit_type.rs
index f9f826b88..38a351a54 100644
--- a/crates/ra_assists/src/assists/add_explicit_type.rs
+++ b/crates/ra_assists/src/assists/add_explicit_type.rs
@@ -1,7 +1,7 @@
 use hir::{db::HirDatabase, HirDisplay};
 use ra_syntax::{
     ast::{self, AstNode, LetStmt, NameOwner},
-    T,
+    TextRange, T,
 };
 
 use crate::{Assist, AssistCtx, AssistId};
@@ -34,6 +34,14 @@ pub(crate) fn add_explicit_type(ctx: AssistCtx<impl HirDatabase>) -> Option<Assi
     // The binding must have a name
     let name = pat.name()?;
     let name_range = name.syntax().text_range();
+    // Assist should only be applicable if cursor is between 'let' and '='
+    let stmt_range = stmt.syntax().text_range();
+    let eq_range = stmt.eq_token()?.text_range();
+    let let_range = TextRange::from_to(stmt_range.start(), eq_range.start());
+    let cursor_in_range = ctx.frange.range.is_subrange(&let_range);
+    if !cursor_in_range {
+        return None;
+    }
     // Assist not applicable if the type has already been specified
     if stmt.syntax().children_with_tokens().any(|child| child.kind() == T![:]) {
         return None;
@@ -109,4 +117,20 @@ mod tests {
     fn add_explicit_type_not_applicable_if_specified_ty_is_tuple() {
         check_assist_not_applicable(add_explicit_type, "fn f() { let a<|>: (i32, i32) = (3, 4); }");
     }
+
+    #[test]
+    fn add_explicit_type_not_applicable_if_cursor_after_equals() {
+        check_assist_not_applicable(
+            add_explicit_type,
+            "fn f() {let a =<|> match 1 {2 => 3, 3 => 5};}",
+        )
+    }
+
+    #[test]
+    fn add_explicit_type_not_applicable_if_cursor_before_let() {
+        check_assist_not_applicable(
+            add_explicit_type,
+            "fn f() <|>{let a = match 1 {2 => 3, 3 => 5};}",
+        )
+    }
 }
diff --git a/crates/ra_assists/src/assists/auto_import.rs b/crates/ra_assists/src/assists/auto_import.rs
new file mode 100644
index 000000000..9163cc662
--- /dev/null
+++ b/crates/ra_assists/src/assists/auto_import.rs
@@ -0,0 +1,222 @@
+use hir::db::HirDatabase;
+use ra_syntax::{
+    ast::{self, AstNode},
+    SmolStr, SyntaxElement,
+    SyntaxKind::{NAME_REF, USE_ITEM},
+    SyntaxNode,
+};
+
+use crate::{
+    assist_ctx::{ActionBuilder, Assist, AssistCtx},
+    auto_import_text_edit, AssistId, ImportsLocator,
+};
+
+// Assist: auto_import
+//
+// If the name is unresolved, provides all possible imports for it.
+//
+// ```
+// fn main() {
+//     let map = HashMap<|>::new();
+// }
+// ```
+// ->
+// ```
+// use std::collections::HashMap;
+//
+// fn main() {
+//     let map = HashMap<|>::new();
+// }
+// ```
+pub(crate) fn auto_import<F: ImportsLocator>(
+    ctx: AssistCtx<impl HirDatabase>,
+    imports_locator: &mut F,
+) -> Option<Assist> {
+    let path: ast::Path = ctx.find_node_at_offset()?;
+    let module = path.syntax().ancestors().find_map(ast::Module::cast);
+    let position = match module.and_then(|it| it.item_list()) {
+        Some(item_list) => item_list.syntax().clone(),
+        None => {
+            let current_file = path.syntax().ancestors().find_map(ast::SourceFile::cast)?;
+            current_file.syntax().clone()
+        }
+    };
+    let source_analyzer = ctx.source_analyzer(&position, None);
+    let module_with_name_to_import = source_analyzer.module()?;
+    let path_to_import = ctx.covering_element().ancestors().find_map(ast::Path::cast)?;
+    if source_analyzer.resolve_path(ctx.db, &path_to_import).is_some() {
+        return None;
+    }
+
+    let name_to_import = &find_applicable_name_ref(ctx.covering_element())?.syntax().to_string();
+    let proposed_imports = imports_locator
+        .find_imports(&name_to_import.to_string())
+        .into_iter()
+        .filter_map(|module_def| module_with_name_to_import.find_use_path(ctx.db, module_def))
+        .filter(|use_path| !use_path.segments.is_empty())
+        .take(20)
+        .map(|import| import.to_string())
+        .collect::<std::collections::BTreeSet<_>>();
+    if proposed_imports.is_empty() {
+        return None;
+    }
+
+    ctx.add_assist_group(AssistId("auto_import"), "auto import", || {
+        proposed_imports
+            .into_iter()
+            .map(|import| import_to_action(import, &position, &path_to_import.syntax()))
+            .collect()
+    })
+}
+
+fn find_applicable_name_ref(element: SyntaxElement) -> Option<ast::NameRef> {
+    if element.ancestors().find(|ancestor| ancestor.kind() == USE_ITEM).is_some() {
+        None
+    } else if element.kind() == NAME_REF {
+        Some(element.as_node().cloned().and_then(ast::NameRef::cast)?)
+    } else {
+        let parent = element.parent()?;
+        if parent.kind() == NAME_REF {
+            Some(ast::NameRef::cast(parent)?)
+        } else {
+            None
+        }
+    }
+}
+
+fn import_to_action(import: String, position: &SyntaxNode, anchor: &SyntaxNode) -> ActionBuilder {
+    let mut action_builder = ActionBuilder::default();
+    action_builder.label(format!("Import `{}`", &import));
+    auto_import_text_edit(
+        position,
+        anchor,
+        &[SmolStr::new(import)],
+        action_builder.text_edit_builder(),
+    );
+    action_builder
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::helpers::{
+        check_assist_with_imports_locator, check_assist_with_imports_locator_not_applicable,
+        TestImportsLocator,
+    };
+
+    #[test]
+    fn applicable_when_found_an_import() {
+        check_assist_with_imports_locator(
+            auto_import,
+            TestImportsLocator::new,
+            r"
+            PubStruct<|>
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+            r"
+            use PubMod::PubStruct;
+
+            PubStruct<|>
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn applicable_when_found_multiple_imports() {
+        check_assist_with_imports_locator(
+            auto_import,
+            TestImportsLocator::new,
+            r"
+            PubStruct<|>
+
+            pub mod PubMod1 {
+                pub struct PubStruct;
+            }
+            pub mod PubMod2 {
+                pub struct PubStruct;
+            }
+            pub mod PubMod3 {
+                pub struct PubStruct;
+            }
+            ",
+            r"
+            use PubMod1::PubStruct;
+
+            PubStruct<|>
+
+            pub mod PubMod1 {
+                pub struct PubStruct;
+            }
+            pub mod PubMod2 {
+                pub struct PubStruct;
+            }
+            pub mod PubMod3 {
+                pub struct PubStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_for_already_imported_types() {
+        check_assist_with_imports_locator_not_applicable(
+            auto_import,
+            TestImportsLocator::new,
+            r"
+            use PubMod::PubStruct;
+
+            PubStruct<|>
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_for_types_with_private_paths() {
+        check_assist_with_imports_locator_not_applicable(
+            auto_import,
+            TestImportsLocator::new,
+            r"
+            PrivateStruct<|>
+
+            pub mod PubMod {
+                struct PrivateStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_when_no_imports_found() {
+        check_assist_with_imports_locator_not_applicable(
+            auto_import,
+            TestImportsLocator::new,
+            "
+            PubStruct<|>",
+        );
+    }
+
+    #[test]
+    fn not_applicable_in_import_statements() {
+        check_assist_with_imports_locator_not_applicable(
+            auto_import,
+            TestImportsLocator::new,
+            r"
+            use PubStruct<|>;
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }",
+        );
+    }
+}
diff --git a/crates/ra_assists/src/assists/inline_local_variable.rs b/crates/ra_assists/src/assists/inline_local_variable.rs
index 45e0f983f..83527d904 100644
--- a/crates/ra_assists/src/assists/inline_local_variable.rs
+++ b/crates/ra_assists/src/assists/inline_local_variable.rs
@@ -23,7 +23,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     (1 + 2) * 4;
 // }
 // ```
-pub(crate) fn inline_local_varialbe(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn inline_local_variable(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
     let let_stmt = ctx.find_node_at_offset::<ast::LetStmt>()?;
     let bind_pat = match let_stmt.pat()? {
         ast::Pat::BindPat(pat) => pat,
@@ -47,6 +47,9 @@ pub(crate) fn inline_local_varialbe(ctx: AssistCtx<impl HirDatabase>) -> Option<
     };
     let analyzer = ctx.source_analyzer(bind_pat.syntax(), None);
     let refs = analyzer.find_all_refs(&bind_pat);
+    if refs.is_empty() {
+        return None;
+    };
 
     let mut wrap_in_parens = vec![true; refs.len()];
 
@@ -117,7 +120,7 @@ mod tests {
     #[test]
     fn test_inline_let_bind_literal_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn bar(a: usize) {}
 fn foo() {
@@ -151,7 +154,7 @@ fn foo() {
     #[test]
     fn test_inline_let_bind_bin_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn bar(a: usize) {}
 fn foo() {
@@ -185,7 +188,7 @@ fn foo() {
     #[test]
     fn test_inline_let_bind_function_call_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn bar(a: usize) {}
 fn foo() {
@@ -219,7 +222,7 @@ fn foo() {
     #[test]
     fn test_inline_let_bind_cast_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn bar(a: usize): usize { a }
 fn foo() {
@@ -253,7 +256,7 @@ fn foo() {
     #[test]
     fn test_inline_let_bind_block_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let a<|> = { 10 + 1 };
@@ -285,7 +288,7 @@ fn foo() {
     #[test]
     fn test_inline_let_bind_paren_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let a<|> = ( 10 + 1 );
@@ -317,7 +320,7 @@ fn foo() {
     #[test]
     fn test_not_inline_mut_variable() {
         check_assist_not_applicable(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let mut a<|> = 1 + 1;
@@ -329,7 +332,7 @@ fn foo() {
     #[test]
     fn test_call_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let a<|> = bar(10 + 1);
@@ -347,7 +350,7 @@ fn foo() {
     #[test]
     fn test_index_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let x = vec![1, 2, 3];
@@ -367,7 +370,7 @@ fn foo() {
     #[test]
     fn test_method_call_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let bar = vec![1];
@@ -387,7 +390,7 @@ fn foo() {
     #[test]
     fn test_field_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 struct Bar {
     foo: usize
@@ -415,7 +418,7 @@ fn foo() {
     #[test]
     fn test_try_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() -> Option<usize> {
     let bar = Some(1);
@@ -437,7 +440,7 @@ fn foo() -> Option<usize> {
     #[test]
     fn test_ref_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let bar = 10;
@@ -455,7 +458,7 @@ fn foo() {
     #[test]
     fn test_tuple_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let a<|> = (10, 20);
@@ -471,7 +474,7 @@ fn foo() {
     #[test]
     fn test_array_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let a<|> = [1, 2, 3];
@@ -487,7 +490,7 @@ fn foo() {
     #[test]
     fn test_paren() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let a<|> = (10 + 20);
@@ -505,7 +508,7 @@ fn foo() {
     #[test]
     fn test_path_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let d = 10;
@@ -525,7 +528,7 @@ fn foo() {
     #[test]
     fn test_block_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let a<|> = { 10 };
@@ -543,7 +546,7 @@ fn foo() {
     #[test]
     fn test_used_in_different_expr1() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let a<|> = 10 + 20;
@@ -565,7 +568,7 @@ fn foo() {
     #[test]
     fn test_used_in_for_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let a<|> = vec![10, 20];
@@ -581,7 +584,7 @@ fn foo() {
     #[test]
     fn test_used_in_while_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let a<|> = 1 > 0;
@@ -597,7 +600,7 @@ fn foo() {
     #[test]
     fn test_used_in_break_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let a<|> = 1 + 1;
@@ -617,7 +620,7 @@ fn foo() {
     #[test]
     fn test_used_in_return_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let a<|> = 1 > 0;
@@ -633,7 +636,7 @@ fn foo() {
     #[test]
     fn test_used_in_match_expr() {
         check_assist(
-            inline_local_varialbe,
+            inline_local_variable,
             "
 fn foo() {
     let a<|> = 1 > 0;
@@ -645,4 +648,16 @@ fn foo() {
 }",
         );
     }
+
+    #[test]
+    fn test_not_applicable_if_variable_unused() {
+        check_assist_not_applicable(
+            inline_local_variable,
+            "
+fn foo() {
+    let <|>a = 0;
+}
+            ",
+        )
+    }
 }