7 files changed, 112 insertions, 32 deletions

diff --git a/crates/ra_assists/src/add_explicit_type.rs b/crates/ra_assists/src/add_explicit_type.rs
new file mode 100644
index 000000000..cb0ac9885
--- /dev/null
+++ b/crates/ra_assists/src/add_explicit_type.rs
@@ -0,0 +1,89 @@
+use hir::{
+    HirDisplay, Ty,
+    db::HirDatabase,
+};
+use ra_syntax::{
+    SyntaxKind,
+    ast::{LetStmt, PatKind, NameOwner, AstNode}
+};
+
+use crate::{AssistCtx, Assist, AssistId};
+
+/// Add explicit type assist.
+pub(crate) fn add_explicit_type(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+    let stmt = ctx.node_at_offset::<LetStmt>()?;
+    let expr = stmt.initializer()?;
+    let pat = stmt.pat()?;
+    // Must be a binding
+    let pat = match pat.kind() {
+        PatKind::BindPat(bind_pat) => bind_pat,
+        _ => return None,
+    };
+    let pat_range = pat.syntax().range();
+    // The binding must have a name
+    let name = pat.name()?;
+    let name_range = name.syntax().range();
+    // Assist not applicable if the type has already been specified
+    if stmt.syntax().children_with_tokens().any(|child| child.kind() == SyntaxKind::COLON) {
+        return None;
+    }
+    // Infer type
+    let db = ctx.db;
+    let analyzer = hir::SourceAnalyzer::new(db, ctx.frange.file_id, stmt.syntax(), None);
+    let ty = analyzer.type_of(db, expr)?;
+    // Assist not applicable if the type is unknown
+    if is_unknown(&ty) {
+        return None;
+    }
+
+    ctx.add_action(AssistId("add_explicit_type"), "add explicit type", |edit| {
+        edit.target(pat_range);
+        edit.insert(name_range.end(), format!(": {}", ty.display(db)));
+    });
+    ctx.build()
+}
+
+/// Returns true if any type parameter is unknown
+fn is_unknown(ty: &Ty) -> bool {
+    match ty {
+        Ty::Unknown => true,
+        Ty::Apply(a_ty) => a_ty.parameters.iter().any(is_unknown),
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::helpers::{ check_assist, check_assist_target, check_assist_not_applicable };
+
+    #[test]
+    fn add_explicit_type_target() {
+        check_assist_target(add_explicit_type, "fn f() { let a<|> = 1; }", "a");
+    }
+
+    #[test]
+    fn add_explicit_type_works_for_simple_expr() {
+        check_assist(
+            add_explicit_type,
+            "fn f() { let a<|> = 1; }",
+            "fn f() { let a<|>: i32 = 1; }",
+        );
+    }
+
+    #[test]
+    fn add_explicit_type_not_applicable_if_ty_not_inferred() {
+        check_assist_not_applicable(add_explicit_type, "fn f() { let a<|> = None; }");
+    }
+
+    #[test]
+    fn add_explicit_type_not_applicable_if_ty_already_specified() {
+        check_assist_not_applicable(add_explicit_type, "fn f() { let a<|>: i32 = 1; }");
+    }
+
+    #[test]
+    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); }");
+    }
+}
diff --git a/crates/ra_assists/src/add_missing_impl_members.rs b/crates/ra_assists/src/add_missing_impl_members.rs
index 19a2d05bc..100ebb7b6 100644
--- a/crates/ra_assists/src/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/add_missing_impl_members.rs
@@ -2,7 +2,6 @@ use std::fmt::Write;
 
 use crate::{Assist, AssistId, AssistCtx};
 
-use hir::Resolver;
 use hir::db::HirDatabase;
 use ra_syntax::{SmolStr, SyntaxKind, TextRange, TextUnit, TreeArc};
 use ra_syntax::ast::{self, AstNode, AstToken, FnDef, ImplItem, ImplItemKind, NameOwner};
@@ -46,9 +45,9 @@ fn add_missing_impl_members_inner(
     let trait_def = {
         let file_id = ctx.frange.file_id;
         let position = FilePosition { file_id, offset: impl_node.syntax().range().start() };
-        let resolver = hir::source_binder::resolver_for_position(ctx.db, position);
+        let analyzer = hir::SourceAnalyzer::new(ctx.db, position.file_id, impl_node.syntax(), None);
 
-        resolve_target_trait_def(ctx.db, &resolver, impl_node)?
+        resolve_target_trait_def(ctx.db, &analyzer, impl_node)?
     };
 
     let missing_fns: Vec<_> = {
@@ -122,14 +121,14 @@ fn add_missing_impl_members_inner(
 /// implemented) to a `ast::TraitDef`.
 fn resolve_target_trait_def(
     db: &impl HirDatabase,
-    resolver: &Resolver,
+    analyzer: &hir::SourceAnalyzer,
     impl_block: &ast::ImplBlock,
 ) -> Option<TreeArc<ast::TraitDef>> {
-    let ast_path = impl_block.target_trait().map(AstNode::syntax).and_then(ast::PathType::cast)?;
-    let hir_path = ast_path.path().and_then(hir::Path::from_ast)?;
+    let ast_path =
+        impl_block.target_trait().map(AstNode::syntax).and_then(ast::PathType::cast)?.path()?;
 
-    match resolver.resolve_path(db, &hir_path).take_types() {
-        Some(hir::Resolution::Def(hir::ModuleDef::Trait(def))) => Some(def.source(db).1),
+    match analyzer.resolve_path(db, &ast_path) {
+        Some(hir::PathResolution::Def(hir::ModuleDef::Trait(def))) => Some(def.source(db).1),
         _ => None,
     }
 }
diff --git a/crates/ra_assists/src/fill_match_arms.rs b/crates/ra_assists/src/fill_match_arms.rs
index da67ab667..45e327cd4 100644
--- a/crates/ra_assists/src/fill_match_arms.rs
+++ b/crates/ra_assists/src/fill_match_arms.rs
@@ -1,7 +1,7 @@
 use std::fmt::Write;
 
 use hir::{
-    AdtDef, FieldSource, source_binder,
+    AdtDef, FieldSource,
     db::HirDatabase,
 };
 use ra_syntax::ast::{self, AstNode};
@@ -20,12 +20,8 @@ pub(crate) fn fill_match_arms(mut ctx: AssistCtx<impl HirDatabase>) -> Option<As
     }
 
     let expr = match_expr.expr()?;
-    let function =
-        source_binder::function_from_child_node(ctx.db, ctx.frange.file_id, expr.syntax())?;
-    let infer_result = function.infer(ctx.db);
-    let source_map = function.body_source_map(ctx.db);
-    let node_expr = source_map.node_expr(expr)?;
-    let match_expr_ty = infer_result[node_expr].clone();
+    let analyzer = hir::SourceAnalyzer::new(ctx.db, ctx.frange.file_id, expr.syntax(), None);
+    let match_expr_ty = analyzer.type_of(ctx.db, expr)?;
     let enum_def = match_expr_ty.autoderef(ctx.db).find_map(|ty| match ty.as_adt() {
         Some((AdtDef::Enum(e), _)) => Some(e),
         _ => None,
diff --git a/crates/ra_assists/src/fill_struct_fields.rs b/crates/ra_assists/src/fill_struct_fields.rs
index c7790dc72..663b4f669 100644
--- a/crates/ra_assists/src/fill_struct_fields.rs
+++ b/crates/ra_assists/src/fill_struct_fields.rs
@@ -1,6 +1,6 @@
 use std::fmt::Write;
 
-use hir::{AdtDef, db::HirDatabase, source_binder::function_from_child_node};
+use hir::{AdtDef, db::HirDatabase};
 
 use ra_syntax::ast::{self, AstNode};
 
@@ -51,15 +51,13 @@ where
     }
 
     fn evaluate_struct_def_fields(&mut self) -> Option<()> {
-        let function = function_from_child_node(
+        let analyzer = hir::SourceAnalyzer::new(
             self.ctx.db,
             self.ctx.frange.file_id,
             self.struct_lit.syntax(),
-        )?;
-        let infer_result = function.infer(self.ctx.db);
-        let source_map = function.body_source_map(self.ctx.db);
-        let node_expr = source_map.node_expr(self.struct_lit.into())?;
-        let struct_lit_ty = infer_result[node_expr].clone();
+            None,
+        );
+        let struct_lit_ty = analyzer.type_of(self.ctx.db, self.struct_lit.into())?;
         let struct_def = match struct_lit_ty.as_adt() {
             Some((AdtDef::Struct(s), _)) => s,
             _ => return None,
diff --git a/crates/ra_assists/src/inline_local_variable.rs b/crates/ra_assists/src/inline_local_variable.rs
index 950c2910b..e0479ef13 100644
--- a/crates/ra_assists/src/inline_local_variable.rs
+++ b/crates/ra_assists/src/inline_local_variable.rs
@@ -1,7 +1,4 @@
-use hir::{
-    db::HirDatabase,
-    source_binder::function_from_child_node,
-};
+use hir::db::HirDatabase;
 use ra_syntax::{
     ast::{self, AstNode, AstToken, PatKind, ExprKind},
     TextRange,
@@ -29,10 +26,8 @@ pub(crate) fn inline_local_varialbe(mut ctx: AssistCtx<impl HirDatabase>) -> Opt
     } else {
         let_stmt.syntax().range()
     };
-
-    let function = function_from_child_node(ctx.db, ctx.frange.file_id, bind_pat.syntax())?;
-    let scope = function.scopes(ctx.db);
-    let refs = scope.find_all_refs(bind_pat);
+    let analyzer = hir::SourceAnalyzer::new(ctx.db, ctx.frange.file_id, bind_pat.syntax(), None);
+    let refs = analyzer.find_all_refs(bind_pat);
 
     let mut wrap_in_parens = vec![true; refs.len()];
 
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index c1514f8e5..ded401b63 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -86,6 +86,7 @@ where
 }
 
 mod add_derive;
+mod add_explicit_type;
 mod add_impl;
 mod flip_comma;
 mod flip_binexpr;
@@ -103,6 +104,7 @@ mod add_missing_impl_members;
 fn all_assists<DB: HirDatabase>() -> &'static [fn(AssistCtx<DB>) -> Option<Assist>] {
     &[
         add_derive::add_derive,
+        add_explicit_type::add_explicit_type,
         add_impl::add_impl,
         change_visibility::change_visibility,
         fill_match_arms::fill_match_arms,
diff --git a/crates/ra_assists/src/split_import.rs b/crates/ra_assists/src/split_import.rs
index 4bf1852db..57e0efaf2 100644
--- a/crates/ra_assists/src/split_import.rs
+++ b/crates/ra_assists/src/split_import.rs
@@ -1,8 +1,9 @@
+use std::iter::successors;
+
 use hir::db::HirDatabase;
 use ra_syntax::{
     TextUnit, AstNode, SyntaxKind::COLONCOLON,
     ast,
-    algo::generate,
 };
 
 use crate::{AssistCtx, Assist, AssistId};
@@ -10,7 +11,7 @@ use crate::{AssistCtx, Assist, AssistId};
 pub(crate) fn split_import(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
     let colon_colon = ctx.token_at_offset().find(|leaf| leaf.kind() == COLONCOLON)?;
     let path = ast::Path::cast(colon_colon.parent())?;
-    let top_path = generate(Some(path), |it| it.parent_path()).last()?;
+    let top_path = successors(Some(path), |it| it.parent_path()).last()?;
 
     let use_tree = top_path.syntax().ancestors().find_map(ast::UseTree::cast);
     if use_tree.is_none() {