Move FunctionSignature creation to display

crates/ra_ide_api/src/call_info.rs

@@ -8,7 +8,7 @@ use ra_syntax::{
 };
 use hir::Docs;
 
-use crate::{FilePosition, CallInfo, db::RootDatabase};
+use crate::{FilePosition, CallInfo, FunctionSignature, db::RootDatabase};
 
 /// Computes parameter information for the given call expression.
 pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<CallInfo> {
@@ -108,11 +108,10 @@ impl<'a> FnCallNode<'a> {
 
 impl CallInfo {
     fn new(db: &RootDatabase, function: hir::Function, node: &ast::FnDef) -> Option<Self> {
-        let sig = crate::completion::function_signature(node)?;
         let doc = function.docs(db);
-        let sig = sig.with_doc_opt(doc);
+        let signature = FunctionSignature::from(node).with_doc_opt(doc);
 
-        Some(CallInfo { signature: sig, active_parameter: None })
+        Some(CallInfo { signature, active_parameter: None })
     }
 
     fn parameters(&self) -> &[String] {

crates/ra_ide_api/src/completion.rs

@@ -13,7 +13,7 @@ mod complete_scope;
 mod complete_postfix;
 
 use ra_db::SourceDatabase;
-use ra_syntax::{ast::{self, AstNode, NameOwner, VisibilityOwner, TypeParamsOwner}, SyntaxKind::{ATTR, COMMENT}};
+use ra_syntax::{ast::{self, AstNode}, SyntaxKind::{ATTR, COMMENT}};
 
 use crate::{
     db,
@@ -72,52 +72,8 @@ pub(crate) fn completions(db: &db::RootDatabase, position: FilePosition) -> Opti
     Some(acc)
 }
 
-pub fn generic_parameters<N: TypeParamsOwner>(node: &N) -> Vec<String> {
-    let mut res = vec![];
-    if let Some(type_params) = node.type_param_list() {
-        res.extend(type_params.lifetime_params().map(|p| p.syntax().text().to_string()));
-        res.extend(type_params.type_params().map(|p| p.syntax().text().to_string()));
-    }
-    res
-}
-
-pub fn where_predicates<N: TypeParamsOwner>(node: &N) -> Vec<String> {
-    let mut res = vec![];
-    if let Some(clause) = node.where_clause() {
-        res.extend(clause.predicates().map(|p| p.syntax().text().to_string()));
-    }
-    res
-}
-
-pub fn function_signature(node: &ast::FnDef) -> Option<FunctionSignature> {
-    fn param_list(node: &ast::FnDef) -> Vec<String> {
-        let mut res = vec![];
-        if let Some(param_list) = node.param_list() {
-            if let Some(self_param) = param_list.self_param() {
-                res.push(self_param.syntax().text().to_string())
-            }
-
-            res.extend(param_list.params().map(|param| param.syntax().text().to_string()));
-        }
-        res
-    }
-
-    let sig = FunctionSignature {
-        visibility: node.visibility().map(|n| n.syntax().text().to_string()),
-        name: node.name().map(|n| n.text().to_string()),
-        ret_type: node.ret_type().and_then(|r| r.type_ref()).map(|n| n.syntax().text().to_string()),
-        parameters: param_list(node),
-        generic_parameters: generic_parameters(node),
-        where_predicates: where_predicates(node),
-        // docs are processed separately
-        doc: None,
-    };
-
-    Some(sig)
-}
-
 pub fn function_label(node: &ast::FnDef) -> Option<String> {
-    function_signature(node).map(|n| n.to_string())
+    Some(FunctionSignature::from(node).to_string())
 }
 
 pub fn const_label(node: &ast::ConstDef) -> String {

crates/ra_ide_api/src/display.rs

@@ -3,6 +3,8 @@
 use super::*;
 use std::fmt::{self, Display};
 use join_to_string::join;
+use ra_syntax::ast::{self, AstNode, NameOwner, VisibilityOwner, TypeParamsOwner};
+use std::convert::From;
 
 /// Contains information about a function signature
 #[derive(Debug)]
@@ -30,6 +32,36 @@ impl FunctionSignature {
     }
 }
 
+impl From<&'_ ast::FnDef> for FunctionSignature {
+    fn from(node: &ast::FnDef) -> FunctionSignature {
+        fn param_list(node: &ast::FnDef) -> Vec<String> {
+            let mut res = vec![];
+            if let Some(param_list) = node.param_list() {
+                if let Some(self_param) = param_list.self_param() {
+                    res.push(self_param.syntax().text().to_string())
+                }
+
+                res.extend(param_list.params().map(|param| param.syntax().text().to_string()));
+            }
+            res
+        }
+
+        FunctionSignature {
+            visibility: node.visibility().map(|n| n.syntax().text().to_string()),
+            name: node.name().map(|n| n.text().to_string()),
+            ret_type: node
+                .ret_type()
+                .and_then(|r| r.type_ref())
+                .map(|n| n.syntax().text().to_string()),
+            parameters: param_list(node),
+            generic_parameters: generic_parameters(node),
+            where_predicates: where_predicates(node),
+            // docs are processed separately
+            doc: None,
+        }
+    }
+}
+
 impl Display for FunctionSignature {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if let Some(t) = &self.visibility {
@@ -61,3 +93,20 @@ impl Display for FunctionSignature {
         Ok(())
     }
 }
+
+pub(crate) fn generic_parameters<N: TypeParamsOwner>(node: &N) -> Vec<String> {
+    let mut res = vec![];
+    if let Some(type_params) = node.type_param_list() {
+        res.extend(type_params.lifetime_params().map(|p| p.syntax().text().to_string()));
+        res.extend(type_params.type_params().map(|p| p.syntax().text().to_string()));
+    }
+    res
+}
+
+pub(crate) fn where_predicates<N: TypeParamsOwner>(node: &N) -> Vec<String> {
+    let mut res = vec![];
+    if let Some(clause) = node.where_clause() {
+        res.extend(clause.predicates().map(|p| p.syntax().text().to_string()));
+    }
+    res
+}