13 files changed, 203 insertions, 73 deletions

diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index 853e17bae..be5d17d85 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -372,8 +372,9 @@ where
                         arg_types.push(type_ref);
                     }
                 }
+                let ret_type = e.ret_type().and_then(|r| r.type_ref()).map(TypeRef::from_ast);
                 let body = self.collect_expr_opt(e.body());
-                self.alloc_expr(Expr::Lambda { args, arg_types, body }, syntax_ptr)
+                self.alloc_expr(Expr::Lambda { args, arg_types, ret_type, body }, syntax_ptr)
             }
             ast::Expr::BinExpr(e) => {
                 let lhs = self.collect_expr_opt(e.lhs());
diff --git a/crates/ra_hir_def/src/expr.rs b/crates/ra_hir_def/src/expr.rs
index 6fad80a8d..a75ef9970 100644
--- a/crates/ra_hir_def/src/expr.rs
+++ b/crates/ra_hir_def/src/expr.rs
@@ -143,6 +143,7 @@ pub enum Expr {
     Lambda {
         args: Vec<PatId>,
         arg_types: Vec<Option<TypeRef>>,
+        ret_type: Option<TypeRef>,
         body: ExprId,
     },
     Tuple {
diff --git a/crates/ra_hir_def/src/path.rs b/crates/ra_hir_def/src/path.rs
index 00325cd99..8e1294201 100644
--- a/crates/ra_hir_def/src/path.rs
+++ b/crates/ra_hir_def/src/path.rs
@@ -135,7 +135,7 @@ impl Path {
     }
 
     pub fn type_anchor(&self) -> Option<&TypeRef> {
-        self.type_anchor.as_ref().map(|it| &**it)
+        self.type_anchor.as_deref()
     }
 
     pub fn segments(&self) -> PathSegments<'_> {
diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs
index bbbc391c4..e97b81473 100644
--- a/crates/ra_hir_ty/src/infer.rs
+++ b/crates/ra_hir_ty/src/infer.rs
@@ -196,7 +196,12 @@ struct InferenceContext<'a, D: HirDatabase> {
     trait_env: Arc<TraitEnvironment>,
     obligations: Vec<Obligation>,
     result: InferenceResult,
-    /// The return type of the function being inferred.
+    /// The return type of the function being inferred, or the closure if we're
+    /// currently within one.
+    ///
+    /// We might consider using a nested inference context for checking
+    /// closures, but currently this is the only field that will change there,
+    /// so it doesn't make sense.
     return_ty: Ty,
 
     /// Impls of `CoerceUnsized` used in coercion.
@@ -455,7 +460,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     }
 
     fn infer_body(&mut self) {
-        self.infer_expr(self.body.body_expr, &Expectation::has_type(self.return_ty.clone()));
+        self.infer_expr_coerce(self.body.body_expr, &Expectation::has_type(self.return_ty.clone()));
     }
 
     fn resolve_into_iter_item(&self) -> Option<TypeAliasId> {
diff --git a/crates/ra_hir_ty/src/infer/coerce.rs b/crates/ra_hir_ty/src/infer/coerce.rs
index 0f4dac45e..83c0c2c3f 100644
--- a/crates/ra_hir_ty/src/infer/coerce.rs
+++ b/crates/ra_hir_ty/src/infer/coerce.rs
@@ -134,6 +134,10 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 }
             }
 
+            (ty_app!(TypeCtor::Closure { .. }, params), ty_app!(TypeCtor::FnPtr { .. })) => {
+                from_ty = params[0].clone();
+            }
+
             _ => {}
         }
 
diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs
index 8be567917..3af05394c 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -41,7 +41,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 
     /// Infer type of expression with possibly implicit coerce to the expected type.
     /// Return the type after possible coercion.
-    fn infer_expr_coerce(&mut self, expr: ExprId, expected: &Expectation) -> Ty {
+    pub(super) fn infer_expr_coerce(&mut self, expr: ExprId, expected: &Expectation) -> Ty {
         let ty = self.infer_expr_inner(expr, &expected);
         let ty = if !self.coerce(&ty, &expected.ty) {
             self.result
@@ -102,7 +102,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
                 Ty::unit()
             }
-            Expr::Lambda { body, args, arg_types } => {
+            Expr::Lambda { body, args, ret_type, arg_types } => {
                 assert_eq!(args.len(), arg_types.len());
 
                 let mut sig_tys = Vec::new();
@@ -118,7 +118,10 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 }
 
                 // add return type
-                let ret_ty = self.table.new_type_var();
+                let ret_ty = match ret_type {
+                    Some(type_ref) => self.make_ty(type_ref),
+                    None => self.table.new_type_var(),
+                };
                 sig_tys.push(ret_ty.clone());
                 let sig_ty = Ty::apply(
                     TypeCtor::FnPtr { num_args: sig_tys.len() as u16 - 1 },
@@ -134,7 +137,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 // infer the body.
                 self.coerce(&closure_ty, &expected.ty);
 
-                self.infer_expr(*body, &Expectation::has_type(ret_ty));
+                let prev_ret_ty = std::mem::replace(&mut self.return_ty, ret_ty.clone());
+
+                self.infer_expr_coerce(*body, &Expectation::has_type(ret_ty));
+
+                self.return_ty = prev_ret_ty;
+
                 closure_ty
             }
             Expr::Call { callee, args } => {
@@ -192,6 +200,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             Expr::Return { expr } => {
                 if let Some(expr) = expr {
                     self.infer_expr_coerce(*expr, &Expectation::has_type(self.return_ty.clone()));
+                } else {
+                    let unit = Ty::unit();
+                    self.coerce(&unit, &self.return_ty.clone());
                 }
                 Ty::simple(TypeCtor::Never)
             }
diff --git a/crates/ra_hir_ty/src/tests/coercion.rs b/crates/ra_hir_ty/src/tests/coercion.rs
index ac9e3872a..7e99a42ed 100644
--- a/crates/ra_hir_ty/src/tests/coercion.rs
+++ b/crates/ra_hir_ty/src/tests/coercion.rs
@@ -370,6 +370,22 @@ fn test() {
 }
 
 #[test]
+fn return_coerce_unknown() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+fn foo() -> u32 {
+    return unknown;
+}
+"#, true),
+        @r###"
+    [17; 40) '{     ...own; }': !
+    [23; 37) 'return unknown': !
+    [30; 37) 'unknown': u32
+    "###
+    );
+}
+
+#[test]
 fn coerce_autoderef() {
     assert_snapshot!(
         infer_with_mismatches(r#"
@@ -440,3 +456,73 @@ fn test() {
     "###
     );
 }
+
+#[test]
+fn closure_return_coerce() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+fn foo() {
+    let x = || {
+        if true {
+            return &1u32;
+        }
+        &&1u32
+    };
+}
+"#, true),
+        @r###"
+    [10; 106) '{     ...  }; }': ()
+    [20; 21) 'x': || -> &u32
+    [24; 103) '|| {  ...     }': || -> &u32
+    [27; 103) '{     ...     }': &u32
+    [37; 82) 'if tru...     }': ()
+    [40; 44) 'true': bool
+    [45; 82) '{     ...     }': !
+    [59; 71) 'return &1u32': !
+    [66; 71) '&1u32': &u32
+    [67; 71) '1u32': u32
+    [91; 97) '&&1u32': &&u32
+    [92; 97) '&1u32': &u32
+    [93; 97) '1u32': u32
+    "###
+    );
+}
+
+#[test]
+fn coerce_fn_item_to_fn_ptr() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+fn foo(x: u32) -> isize { 1 }
+fn test() {
+    let f: fn(u32) -> isize = foo;
+}
+"#, true),
+        @r###"
+    [8; 9) 'x': u32
+    [25; 30) '{ 1 }': isize
+    [27; 28) '1': isize
+    [41; 79) '{     ...foo; }': ()
+    [51; 52) 'f': fn(u32) -> isize
+    [73; 76) 'foo': fn foo(u32) -> isize
+    "###
+    );
+}
+
+#[test]
+fn coerce_closure_to_fn_ptr() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+fn test() {
+    let f: fn(u32) -> isize = |x| { 1 };
+}
+"#, true),
+        @r###"
+    [11; 55) '{     ...1 }; }': ()
+    [21; 22) 'f': fn(u32) -> isize
+    [43; 52) '|x| { 1 }': |u32| -> isize
+    [44; 45) 'x': u32
+    [47; 52) '{ 1 }': isize
+    [49; 50) '1': isize
+    "###
+    );
+}
diff --git a/crates/ra_hir_ty/src/tests/simple.rs b/crates/ra_hir_ty/src/tests/simple.rs
index 18976c9ae..6fe647a5e 100644
--- a/crates/ra_hir_ty/src/tests/simple.rs
+++ b/crates/ra_hir_ty/src/tests/simple.rs
@@ -1606,3 +1606,58 @@ fn main() {
     );
     assert_eq!(t, "u32");
 }
+
+#[test]
+fn closure_return() {
+    assert_snapshot!(
+        infer(r#"
+fn foo() -> u32 {
+    let x = || -> usize { return 1; };
+}
+"#),
+        @r###"
+    [17; 59) '{     ...; }; }': ()
+    [27; 28) 'x': || -> usize
+    [31; 56) '|| -> ...n 1; }': || -> usize
+    [43; 56) '{ return 1; }': !
+    [45; 53) 'return 1': !
+    [52; 53) '1': usize
+    "###
+    );
+}
+
+#[test]
+fn closure_return_unit() {
+    assert_snapshot!(
+        infer(r#"
+fn foo() -> u32 {
+    let x = || { return; };
+}
+"#),
+        @r###"
+    [17; 48) '{     ...; }; }': ()
+    [27; 28) 'x': || -> ()
+    [31; 45) '|| { return; }': || -> ()
+    [34; 45) '{ return; }': !
+    [36; 42) 'return': !
+    "###
+    );
+}
+
+#[test]
+fn closure_return_inferred() {
+    assert_snapshot!(
+        infer(r#"
+fn foo() -> u32 {
+    let x = || { "test" };
+}
+"#),
+        @r###"
+    [17; 47) '{     ..." }; }': ()
+    [27; 28) 'x': || -> &str
+    [31; 44) '|| { "test" }': || -> &str
+    [34; 44) '{ "test" }': &str
+    [36; 42) '"test"': &str
+    "###
+    );
+}
diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index 2d92a5eec..76e2198b6 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -393,11 +393,11 @@ fn test() -> u64 {
     [54; 55) 'a': S
     [58; 59) 'S': S(fn(u32) -> u64) -> S
     [58; 68) 'S(|i| 2*i)': S
-    [60; 67) '|i| 2*i': |i32| -> i32
-    [61; 62) 'i': i32
-    [64; 65) '2': i32
-    [64; 67) '2*i': i32
-    [66; 67) 'i': i32
+    [60; 67) '|i| 2*i': |u32| -> u64
+    [61; 62) 'i': u32
+    [64; 65) '2': u32
+    [64; 67) '2*i': u32
+    [66; 67) 'i': u32
     [78; 79) 'b': u64
     [82; 83) 'a': S
     [82; 85) 'a.0': fn(u32) -> u64
diff --git a/crates/ra_ide/src/display.rs b/crates/ra_ide/src/display.rs
index 30617412a..fbe89841b 100644
--- a/crates/ra_ide/src/display.rs
+++ b/crates/ra_ide/src/display.rs
@@ -15,7 +15,7 @@ pub use function_signature::FunctionSignature;
 pub use navigation_target::NavigationTarget;
 pub use structure::{file_structure, StructureNode};
 
-pub(crate) use navigation_target::{description_from_symbol, docs_from_symbol, ToNav};
+pub(crate) use navigation_target::ToNav;
 pub(crate) use short_label::ShortLabel;
 
 pub(crate) fn function_label(node: &ast::FnDef) -> String {
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index a227bf546..35e39f965 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -12,10 +12,7 @@ use ra_syntax::{
 
 use crate::{
     db::RootDatabase,
-    display::{
-        description_from_symbol, docs_from_symbol, macro_label, rust_code_markup,
-        rust_code_markup_with_doc, ShortLabel,
-    },
+    display::{macro_label, rust_code_markup, rust_code_markup_with_doc, ShortLabel},
     expand::descend_into_macros,
     references::{classify_name, classify_name_ref, NameKind, NameKind::*},
     FilePosition, FileRange, RangeInfo,
@@ -95,11 +92,7 @@ fn hover_text(docs: Option<String>, desc: Option<String>) -> Option<String> {
     }
 }
 
-fn hover_text_from_name_kind(
-    db: &RootDatabase,
-    name_kind: NameKind,
-    no_fallback: &mut bool,
-) -> Option<String> {
+fn hover_text_from_name_kind(db: &RootDatabase, name_kind: NameKind) -> Option<String> {
     return match name_kind {
         Macro(it) => {
             let src = it.source(db);
@@ -135,11 +128,7 @@ fn hover_text_from_name_kind(
             hir::ModuleDef::TypeAlias(it) => from_def_source(db, it),
             hir::ModuleDef::BuiltinType(it) => Some(it.to_string()),
         },
-        Local(_) => {
-            // Hover for these shows type names
-            *no_fallback = true;
-            None
-        }
+        Local(_) => None,
         TypeParam(_) | SelfType(_) => {
             // FIXME: Hover for generic param
             None
@@ -163,60 +152,35 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
 
     let mut res = HoverResult::new();
 
-    let mut range = match_ast! {
+    if let Some((range, name_kind)) = match_ast! {
         match (token.value.parent()) {
             ast::NameRef(name_ref) => {
-                let mut no_fallback = false;
-                if let Some(name_kind) =
-                    classify_name_ref(db, token.with_value(&name_ref)).map(|d| d.kind)
-                {
-                    res.extend(hover_text_from_name_kind(db, name_kind, &mut no_fallback))
-                }
-
-                if res.is_empty() && !no_fallback {
-                    // Fallback index based approach:
-                    let symbols = crate::symbol_index::index_resolve(db, &name_ref);
-                    for sym in symbols {
-                        let docs = docs_from_symbol(db, &sym);
-                        let desc = description_from_symbol(db, &sym);
-                        res.extend(hover_text(docs, desc));
-                    }
-                }
-
-                if !res.is_empty() {
-                    Some(name_ref.syntax().text_range())
-                } else {
-                    None
-                }
+                classify_name_ref(db, token.with_value(&name_ref)).map(|d| (name_ref.syntax().text_range(), d.kind))
             },
             ast::Name(name) => {
-                if let Some(name_kind) = classify_name(db, token.with_value(&name)).map(|d| d.kind) {
-                    res.extend(hover_text_from_name_kind(db, name_kind, &mut true));
-                }
-
-                if !res.is_empty() {
-                    Some(name.syntax().text_range())
-                } else {
-                    None
-                }
+                classify_name(db, token.with_value(&name)).map(|d| (name.syntax().text_range(), d.kind))
             },
             _ => None,
         }
-    };
+    } {
+        res.extend(hover_text_from_name_kind(db, name_kind));
 
-    if range.is_none() {
-        let node = token.value.ancestors().find(|n| {
-            ast::Expr::cast(n.clone()).is_some() || ast::Pat::cast(n.clone()).is_some()
-        })?;
-        let frange = FileRange { file_id: position.file_id, range: node.text_range() };
-        res.extend(type_of(db, frange).map(rust_code_markup));
-        range = Some(node.text_range());
-    };
+        if !res.is_empty() {
+            return Some(RangeInfo::new(range, res));
+        }
+    }
 
-    let range = range?;
+    let node = token
+        .value
+        .ancestors()
+        .find(|n| ast::Expr::cast(n.clone()).is_some() || ast::Pat::cast(n.clone()).is_some())?;
+    let frange = FileRange { file_id: position.file_id, range: node.text_range() };
+    res.extend(type_of(db, frange).map(rust_code_markup));
     if res.is_empty() {
         return None;
     }
+    let range = node.text_range();
+
     Some(RangeInfo::new(range, res))
 }
 
@@ -314,7 +278,7 @@ mod tests {
             &["pub fn foo() -> u32"],
         );
 
-        // Multiple results
+        // Multiple candidates but results are ambiguous.
         check_hover_result(
             r#"
             //- /a.rs
@@ -335,7 +299,7 @@ mod tests {
                 let foo_test = fo<|>o();
             }
         "#,
-            &["pub fn foo() -> &str", "pub fn foo() -> u32", "pub fn foo(a: u32, b: u32)"],
+            &["{unknown}"],
         );
     }
 
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 9dd6bd3ea..8d65e2e08 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -1426,6 +1426,9 @@ impl LambdaExpr {
     pub fn param_list(&self) -> Option<ParamList> {
         AstChildren::new(&self.syntax).next()
     }
+    pub fn ret_type(&self) -> Option<RetType> {
+        AstChildren::new(&self.syntax).next()
+    }
     pub fn body(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index 9ffa9095b..a228fa9d6 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -426,7 +426,7 @@ Grammar(
         "PathExpr": (options: ["Path"]),
         "LambdaExpr": (
             options: [
-                "ParamList",
+                "ParamList", "RetType",
                 ["body", "Expr"],
             ]
         ),