Account for resolved generics for Self-returning methods

One concrete example is when we have a partially resolved generic type
which calls a `Self`-returning method, e.g. `Vec<String, _>::new()`.

Previously, the returned type for `Self`-returning methods would return
the unresolved, generic type as encountered in the impl header (so
`Vec<T, A: AllocRef = Global>` in this case). However, if the method
match already carries some information about generics (T := String
here), make sure to account for it.

Author: Xanewok

src/racer/ast.rs

@@ -527,7 +527,16 @@ impl<'c, 's, 'ast> visit::Visitor<'ast> for ExprTypeVisitor<'c, 's> {
                                     .and_then(|ty| path_to_match(ty, self.session))
                             }
                             MatchType::Method(ref gen) => {
-                                typeinf::get_return_type_of_function(&m, &m, self.session).and_then(
+                                let mut return_ty = typeinf::get_return_type_of_function(&m, &m, self.session);
+                                // Account for already resolved generics if the return type is Self
+                                // (in which case we return bare type as found in the `impl` header)
+                                if let (Some(Ty::Match(ref mut m)), Some(gen)) = (&mut return_ty, gen) {
+                                    let resolved = gen.args().filter_map(|tp| tp.resolved());
+                                    for (l, r) in m.generics_mut().zip(resolved) {
+                                        l.resolve(r.clone());
+                                    }
+                                }
+                                return_ty.and_then(
                                     |ty| {
                                         path_to_match_including_generics(
                                             ty,