1 files changed, 23 insertions, 20 deletions

diff --git a/crates/ra_ide_api/src/call_info.rs b/crates/ra_ide_api/src/call_info.rs
index dbb3853d0..4413aec73 100644
--- a/crates/ra_ide_api/src/call_info.rs
+++ b/crates/ra_ide_api/src/call_info.rs
@@ -2,7 +2,6 @@ use test_utils::tested_by;
 use ra_db::SourceDatabase;
 use ra_syntax::{
     AstNode, SyntaxNode, TextUnit,
-    SyntaxKind::FN_DEF,
     ast::{self, ArgListOwner},
     algo::find_node_at_offset,
 };
@@ -18,19 +17,26 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<Cal
     let calling_node = FnCallNode::with_node(syntax, position.offset)?;
     let name_ref = calling_node.name_ref()?;
 
-    // Resolve the function's NameRef (NOTE: this isn't entirely accurate).
-    let file_symbols = crate::symbol_index::index_resolve(db, name_ref);
-    let symbol = file_symbols.into_iter().find(|it| it.ptr.kind() == FN_DEF)?;
-    let fn_file = db.parse(symbol.file_id);
-    let fn_def = symbol.ptr.to_node(&fn_file);
-    let fn_def = ast::FnDef::cast(fn_def).unwrap();
-    let function = hir::source_binder::function_from_source(db, symbol.file_id, fn_def)?;
+    let analyzer = hir::SourceAnalyzer::new(db, position.file_id, name_ref.syntax(), None);
+    let function = match calling_node {
+        FnCallNode::CallExpr(expr) => {
+            //FIXME: apply subst
+            let (callable_def, _subst) =
+                analyzer.type_of(db, expr.expr()?.into())?.as_callable()?;
+            match callable_def {
+                hir::CallableDef::Function(it) => it,
+                //FIXME: handle other callables
+                _ => return None,
+            }
+        }
+        FnCallNode::MethodCallExpr(expr) => analyzer.resolve_method_call(expr)?,
+    };
 
     let mut call_info = CallInfo::new(db, function);
 
     // If we have a calling expression let's find which argument we are on
     let num_params = call_info.parameters().len();
-    let has_self = fn_def.param_list().and_then(|l| l.self_param()).is_some();
+    let has_self = function.signature(db).has_self_param();
 
     if num_params == 1 {
         if !has_self {
@@ -74,7 +80,7 @@ enum FnCallNode<'a> {
 }
 
 impl<'a> FnCallNode<'a> {
-    pub fn with_node(syntax: &'a SyntaxNode, offset: TextUnit) -> Option<FnCallNode<'a>> {
+    fn with_node(syntax: &'a SyntaxNode, offset: TextUnit) -> Option<FnCallNode<'a>> {
         if let Some(expr) = find_node_at_offset::<ast::CallExpr>(syntax, offset) {
             return Some(FnCallNode::CallExpr(expr));
         }
@@ -84,7 +90,7 @@ impl<'a> FnCallNode<'a> {
         None
     }
 
-    pub fn name_ref(&self) -> Option<&'a ast::NameRef> {
+    fn name_ref(&self) -> Option<&'a ast::NameRef> {
         match *self {
             FnCallNode::CallExpr(call_expr) => Some(match call_expr.expr()?.kind() {
                 ast::ExprKind::PathExpr(path_expr) => path_expr.path()?.segment()?.name_ref()?,
@@ -97,7 +103,7 @@ impl<'a> FnCallNode<'a> {
         }
     }
 
-    pub fn arg_list(&self) -> Option<&'a ast::ArgList> {
+    fn arg_list(&self) -> Option<&'a ast::ArgList> {
         match *self {
             FnCallNode::CallExpr(expr) => expr.arg_list(),
             FnCallNode::MethodCallExpr(expr) => expr.arg_list(),
@@ -142,7 +148,7 @@ mod tests {
     }
 
     #[test]
-    fn test_fn_signature_two_args_first() {
+    fn test_fn_signature_two_args_firstx() {
         let info = call_info(
             r#"fn foo(x: u32, y: u32) -> u32 {x + y}
 fn bar() { foo(<|>3, ); }"#,
@@ -382,11 +388,9 @@ assert_eq!(6, my_crate::add_one(5));
     fn test_fn_signature_with_docs_from_actix() {
         let info = call_info(
             r#"
-pub trait WriteHandler<E>
-where
-    Self: Actor,
-    Self::Context: ActorContext,
-{
+struct WriteHandler<E>;
+
+impl<E> WriteHandler<E> {
     /// Method is called when writer emits error.
     ///
     /// If this method returns `ErrorAction::Continue` writer processing
@@ -403,8 +407,7 @@ where
     }
 }
 
-pub fn foo() {
-    WriteHandler r;
+pub fn foo(mut r: WriteHandler<()>) {
     r.finished(<|>);
 }