3 files changed, 109 insertions, 21 deletions

diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 1f74108a4..26ddf0317 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -41,7 +41,7 @@ use crate::{
         PatId, Statement, UnaryOp,
     },
     generics::{GenericParams, HasGenericParams},
-    name::{INTO_ITERATOR, ITEM, ITER, SELF_TYPE, STD},
+    name,
     nameres::{Namespace, PerNs},
     path::{GenericArg, GenericArgs, PathKind, PathSegment},
     resolve::{
@@ -820,7 +820,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         // Parent arguments are unknown, except for the receiver type
         if let Some(parent_generics) = def_generics.and_then(|p| p.parent_params.clone()) {
             for param in &parent_generics.params {
-                if param.name == SELF_TYPE {
+                if param.name == name::SELF_TYPE {
                     substs.push(receiver_ty.clone());
                 } else {
                     substs.push(Ty::Unknown);
@@ -1117,8 +1117,23 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 self.insert_type_vars(ty)
             }
             Expr::Try { expr } => {
-                let _inner_ty = self.infer_expr(*expr, &Expectation::none());
-                Ty::Unknown
+                let inner_ty = self.infer_expr(*expr, &Expectation::none());
+                let ty = match self.resolve_ops_try_ok() {
+                    Some(ops_try_ok_alias) => {
+                        let ty = self.new_type_var();
+                        let projection = ProjectionPredicate {
+                            ty: ty.clone(),
+                            projection_ty: ProjectionTy {
+                                associated_ty: ops_try_ok_alias,
+                                parameters: vec![inner_ty].into(),
+                            },
+                        };
+                        self.obligations.push(Obligation::Projection(projection));
+                        self.resolve_ty_as_possible(&mut vec![], ty)
+                    }
+                    None => Ty::Unknown,
+                };
+                ty
             }
             Expr::Cast { expr, type_ref } => {
                 let _inner_ty = self.infer_expr(*expr, &Expectation::none());
@@ -1324,15 +1339,33 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         let into_iter_path = Path {
             kind: PathKind::Abs,
             segments: vec![
-                PathSegment { name: STD, args_and_bindings: None },
-                PathSegment { name: ITER, args_and_bindings: None },
-                PathSegment { name: INTO_ITERATOR, args_and_bindings: None },
+                PathSegment { name: name::STD, args_and_bindings: None },
+                PathSegment { name: name::ITER, args_and_bindings: None },
+                PathSegment { name: name::INTO_ITERATOR, args_and_bindings: None },
             ],
         };
 
         match self.resolver.resolve_path_segments(self.db, &into_iter_path).into_fully_resolved() {
             PerNs { types: Some(Def(Trait(trait_))), .. } => {
-                Some(trait_.associated_type_by_name(self.db, ITEM)?)
+                Some(trait_.associated_type_by_name(self.db, name::ITEM)?)
+            }
+            _ => None,
+        }
+    }
+
+    fn resolve_ops_try_ok(&self) -> Option<TypeAlias> {
+        let ops_try_path = Path {
+            kind: PathKind::Abs,
+            segments: vec![
+                PathSegment { name: name::STD, args_and_bindings: None },
+                PathSegment { name: name::OPS, args_and_bindings: None },
+                PathSegment { name: name::TRY, args_and_bindings: None },
+            ],
+        };
+
+        match self.resolver.resolve_path_segments(self.db, &ops_try_path).into_fully_resolved() {
+            PerNs { types: Some(Def(Trait(trait_))), .. } => {
+                Some(trait_.associated_type_by_name(self.db, name::OK)?)
             }
             _ => None,
         }
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index e214bf1af..353820436 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -14,7 +14,7 @@ use crate::{
     nameres::CrateModuleId,
     resolve::Resolver,
     traits::TraitItem,
-    ty::primitive::{UncertainFloatTy, UncertainIntTy},
+    ty::primitive::{FloatBitness, UncertainFloatTy, UncertainIntTy},
     ty::{Ty, TypeCtor},
     Crate, Function, HirDatabase, Module, Name, Trait,
 };
@@ -132,9 +132,11 @@ fn def_crates(db: &impl HirDatabase, cur_crate: Crate, ty: &Ty) -> Option<ArrayV
             TypeCtor::Adt(def_id) => Some(std::iter::once(def_id.krate(db)?).collect()),
             TypeCtor::Bool => lang_item_crate!(db, cur_crate, "bool"),
             TypeCtor::Char => lang_item_crate!(db, cur_crate, "char"),
-            TypeCtor::Float(UncertainFloatTy::Known(f)) => {
-                lang_item_crate!(db, cur_crate, f.ty_to_string())
-            }
+            TypeCtor::Float(UncertainFloatTy::Known(f)) => match f.bitness {
+                // There are two lang items: one in libcore (fXX) and one in libstd (fXX_runtime)
+                FloatBitness::X32 => lang_item_crate!(db, cur_crate, "f32", "f32_runtime"),
+                FloatBitness::X64 => lang_item_crate!(db, cur_crate, "f64", "f64_runtime"),
+            },
             TypeCtor::Int(UncertainIntTy::Known(i)) => {
                 lang_item_crate!(db, cur_crate, i.ty_to_string())
             }
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 7340bb9bd..2410602a6 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -21,19 +21,57 @@ use crate::{
 // update the snapshots.
 
 #[test]
-fn infer_for_loop() {
+fn infer_try() {
     let (mut db, pos) = MockDatabase::with_position(
         r#"
 //- /main.rs
-struct Vec<T> {}
-impl<T> Vec<T> {
-    fn new() -> Self { Vec {} }
-    fn push(&mut self, t: T) { }
+
+fn test() {
+    let r: Result<i32, u64> = Result::Ok(1);
+    let v = r?;
+    v<|>;
 }
 
-impl<T> ::std::iter::IntoIterator for Vec<T> {
-    type Item=T;
+//- /std.rs
+
+#[prelude_import] use ops::*;
+mod ops {
+    trait Try {
+        type Ok;
+        type Error;
+    }
+}
+
+#[prelude_import] use result::*;
+mod result {
+    enum Result<O, E> {
+        Ok(O),
+        Err(E)
+    }
+
+    impl<O, E> crate::ops::Try for Result<O, E> {
+        type Ok = O;
+        type Error = E;
+    }
+}
+
+"#,
+    );
+    db.set_crate_graph_from_fixture(crate_graph! {
+        "main": ("/main.rs", ["std"]),
+        "std": ("/std.rs", []),
+    });
+    assert_eq!("i32", type_at_pos(&db, pos));
 }
+
+#[test]
+fn infer_for_loop() {
+    let (mut db, pos) = MockDatabase::with_position(
+        r#"
+//- /main.rs
+
+use std::collections::Vec;
+
 fn test() {
     let v = Vec::new();
     v.push("foo");
@@ -42,20 +80,35 @@ fn test() {
     }
 }
 
-//- /lib.rs
+//- /std.rs
+
+#[prelude_import] use iter::*;
 mod iter {
     trait IntoIterator {
         type Item;
     }
 }
+
+mod collections {
+    struct Vec<T> {}
+    impl<T> Vec<T> {
+        fn new() -> Self { Vec {} }
+        fn push(&mut self, t: T) { }
+    }
+
+    impl<T> crate::iter::IntoIterator for Vec<T> {
+        type Item=T;
+    }
+}
 "#,
     );
     db.set_crate_graph_from_fixture(crate_graph! {
         "main": ("/main.rs", ["std"]),
-        "std": ("/lib.rs", []),
+        "std": ("/std.rs", []),
     });
     assert_eq!("&str", type_at_pos(&db, pos));
 }
+
 #[test]
 fn infer_basics() {
     assert_snapshot_matches!(