1 files changed, 34 insertions, 4 deletions

diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index db0a20514..f32c77faf 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -165,6 +165,17 @@ impl Substs {
     pub fn empty() -> Substs {
         Substs(Arc::new([]))
     }
+
+    /// Replaces the end of the substitutions by other ones.
+    pub(crate) fn replace_tail(self, replace_by: Vec<Ty>) -> Substs {
+        // again missing Arc::make_mut_slice...
+        let len = replace_by.len().min(self.0.len());
+        let parent_len = self.0.len() - len;
+        let mut result = Vec::with_capacity(parent_len + len);
+        result.extend(self.0.iter().take(parent_len).cloned());
+        result.extend(replace_by);
+        Substs(result.into())
+    }
 }
 
 /// A type. This is based on the `TyKind` enum in rustc (librustc/ty/sty.rs).
@@ -1367,15 +1378,34 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 }
                 ret_ty
             }
-            Expr::MethodCall { receiver, args, method_name } => {
+            Expr::MethodCall { receiver, args, method_name, generic_args } => {
                 let receiver_ty = self.infer_expr(*receiver, &Expectation::none());
                 let resolved = receiver_ty.clone().lookup_method(self.db, method_name);
-                let method_ty = match resolved {
+                let (method_ty, def_generics) = match resolved {
                     Some(func) => {
                         self.write_method_resolution(tgt_expr, func);
-                        self.db.type_for_def(func.into())
+                        (self.db.type_for_def(func.into()), Some(func.generic_params(self.db)))
+                    }
+                    None => (Ty::Unknown, None),
+                };
+                // handle provided type arguments
+                let method_ty = if let Some(generic_args) = generic_args {
+                    // if args are provided, it should be all of them, but we can't rely on that
+                    let param_count = def_generics.map(|g| g.params.len()).unwrap_or(0);
+                    let mut new_substs = Vec::with_capacity(generic_args.args.len());
+                    for arg in generic_args.args.iter().take(param_count) {
+                        match arg {
+                            GenericArg::Type(type_ref) => {
+                                let ty = self.make_ty(type_ref);
+                                new_substs.push(ty);
+                            }
+                        }
                     }
-                    None => Ty::Unknown,
+                    let substs = method_ty.substs().unwrap_or_else(Substs::empty);
+                    let substs = substs.replace_tail(new_substs);
+                    method_ty.apply_substs(substs)
+                } else {
+                    method_ty
                 };
                 let method_ty = self.insert_type_vars(method_ty);
                 let (expected_receiver_ty, param_tys, ret_ty) = match &method_ty {