Merge #5413

5413: Semantical call info r=matklad a=matklad



Co-authored-by: Aleksey Kladov <[email protected]>

9 files changed, 249 insertions, 256 deletions

diff --git a/crates/ra_ide/src/call_hierarchy.rs b/crates/ra_ide/src/call_hierarchy.rs
index cb7e62cd6..6af251d23 100644
--- a/crates/ra_ide/src/call_hierarchy.rs
+++ b/crates/ra_ide/src/call_hierarchy.rs
@@ -95,9 +95,9 @@ pub(crate) fn outgoing_calls(db: &RootDatabase, position: FilePosition) -> Optio
             if let Some(func_target) = match &call_node {
                 FnCallNode::CallExpr(expr) => {
                     //FIXME: Type::as_callable is broken
-                    let callable_def = sema.type_of_expr(&expr.expr()?)?.as_callable()?;
-                    match callable_def {
-                        hir::CallableDefId::FunctionId(it) => {
+                    let callable = sema.type_of_expr(&expr.expr()?)?.as_callable(db)?;
+                    match callable.kind() {
+                        hir::CallableKind::Function(it) => {
                             let fn_def: hir::Function = it.into();
                             let nav = fn_def.to_nav(db);
                             Some(nav)
@@ -109,10 +109,6 @@ pub(crate) fn outgoing_calls(db: &RootDatabase, position: FilePosition) -> Optio
                     let function = sema.resolve_method_call(&expr)?;
                     Some(function.to_nav(db))
                 }
-                FnCallNode::MacroCallExpr(macro_call) => {
-                    let macro_def = sema.resolve_macro_call(&macro_call)?;
-                    Some(macro_def.to_nav(db))
-                }
             } {
                 Some((func_target, name_ref.syntax().text_range()))
             } else {
diff --git a/crates/ra_ide/src/call_info.rs b/crates/ra_ide/src/call_info.rs
index 1fe1c21de..35a8a0dc5 100644
--- a/crates/ra_ide/src/call_info.rs
+++ b/crates/ra_ide/src/call_info.rs
@@ -1,20 +1,42 @@
 //! FIXME: write short doc here
-use hir::Semantics;
+use either::Either;
+use hir::{Docs, HirDisplay, Semantics, Type};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
     ast::{self, ArgListOwner},
-    match_ast, AstNode, SyntaxNode, SyntaxToken,
+    match_ast, AstNode, SyntaxNode, SyntaxToken, TextRange, TextSize,
 };
+use stdx::format_to;
 use test_utils::mark;
 
-use crate::{FilePosition, FunctionSignature};
+use crate::FilePosition;
 
 /// Contains information about a call site. Specifically the
 /// `FunctionSignature`and current parameter.
 #[derive(Debug)]
 pub struct CallInfo {
-    pub signature: FunctionSignature,
+    pub doc: Option<String>,
+    pub signature: String,
     pub active_parameter: Option<usize>,
+    parameters: Vec<TextRange>,
+}
+
+impl CallInfo {
+    pub fn parameter_labels(&self) -> impl Iterator<Item = &str> + '_ {
+        self.parameters.iter().map(move |&it| &self.signature[it])
+    }
+    pub fn parameter_ranges(&self) -> &[TextRange] {
+        &self.parameters
+    }
+    fn push_param(&mut self, param: &str) {
+        if !self.signature.ends_with('(') {
+            self.signature.push_str(", ");
+        }
+        let start = TextSize::of(&self.signature);
+        self.signature.push_str(param);
+        let end = TextSize::of(&self.signature);
+        self.parameters.push(TextRange::new(start, end))
+    }
 }
 
 /// Computes parameter information for the given call expression.
@@ -24,105 +46,130 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<Cal
     let file = file.syntax();
     let token = file.token_at_offset(position.offset).next()?;
     let token = sema.descend_into_macros(token);
-    call_info_for_token(&sema, token)
-}
 
-#[derive(Debug)]
-pub(crate) struct ActiveParameter {
-    /// FIXME: should be `Type` and `Name
-    pub(crate) ty: String,
-    pub(crate) name: String,
-}
+    let (callable, active_parameter) = call_info_impl(&sema, token)?;
 
-impl ActiveParameter {
-    pub(crate) fn at(db: &RootDatabase, position: FilePosition) -> Option<Self> {
-        call_info(db, position)?.into_active_parameter()
+    let mut res =
+        CallInfo { doc: None, signature: String::new(), parameters: vec![], active_parameter };
+
+    match callable.kind() {
+        hir::CallableKind::Function(func) => {
+            res.doc = func.docs(db).map(|it| it.as_str().to_string());
+            format_to!(res.signature, "fn {}", func.name(db));
+        }
+        hir::CallableKind::TupleStruct(strukt) => {
+            res.doc = strukt.docs(db).map(|it| it.as_str().to_string());
+            format_to!(res.signature, "struct {}", strukt.name(db));
+        }
+        hir::CallableKind::TupleEnumVariant(variant) => {
+            res.doc = variant.docs(db).map(|it| it.as_str().to_string());
+            format_to!(
+                res.signature,
+                "enum {}::{}",
+                variant.parent_enum(db).name(db),
+                variant.name(db)
+            );
+        }
     }
 
-    pub(crate) fn at_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Option<Self> {
-        call_info_for_token(sema, token)?.into_active_parameter()
+    res.signature.push('(');
+    {
+        if let Some(self_param) = callable.receiver_param(db) {
+            format_to!(res.signature, "{}", self_param)
+        }
+        let mut buf = String::new();
+        for (pat, ty) in callable.params(db) {
+            buf.clear();
+            if let Some(pat) = pat {
+                match pat {
+                    Either::Left(_self) => format_to!(buf, "self: "),
+                    Either::Right(pat) => format_to!(buf, "{}: ", pat),
+                }
+            }
+            format_to!(buf, "{}", ty.display(db));
+            res.push_param(&buf);
+        }
     }
+    res.signature.push(')');
+
+    match callable.kind() {
+        hir::CallableKind::Function(_) => {
+            let ret_type = callable.return_type();
+            if !ret_type.is_unit() {
+                format_to!(res.signature, " -> {}", ret_type.display(db));
+            }
+        }
+        hir::CallableKind::TupleStruct(_) | hir::CallableKind::TupleEnumVariant(_) => {}
+    }
+    Some(res)
 }
 
-fn call_info_for_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Option<CallInfo> {
+fn call_info_impl(
+    sema: &Semantics<RootDatabase>,
+    token: SyntaxToken,
+) -> Option<(hir::Callable, Option<usize>)> {
     // Find the calling expression and it's NameRef
     let calling_node = FnCallNode::with_node(&token.parent())?;
 
-    let signature = match &calling_node {
-        FnCallNode::CallExpr(call) => {
-            //FIXME: Type::as_callable is broken
-            let callable_def = sema.type_of_expr(&call.expr()?)?.as_callable()?;
-            match callable_def {
-                hir::CallableDefId::FunctionId(it) => {
-                    let fn_def = it.into();
-                    FunctionSignature::from_hir(sema.db, fn_def)
-                }
-                hir::CallableDefId::StructId(it) => {
-                    FunctionSignature::from_struct(sema.db, it.into())?
-                }
-                hir::CallableDefId::EnumVariantId(it) => {
-                    FunctionSignature::from_enum_variant(sema.db, it.into())?
-                }
-            }
-        }
-        FnCallNode::MethodCallExpr(method_call) => {
-            let function = sema.resolve_method_call(&method_call)?;
-            FunctionSignature::from_hir(sema.db, function)
-        }
-        FnCallNode::MacroCallExpr(macro_call) => {
-            let macro_def = sema.resolve_macro_call(&macro_call)?;
-            FunctionSignature::from_macro(sema.db, macro_def)?
+    let callable = match &calling_node {
+        FnCallNode::CallExpr(call) => sema.type_of_expr(&call.expr()?)?.as_callable(sema.db)?,
+        FnCallNode::MethodCallExpr(call) => sema.resolve_method_call_as_callable(call)?,
+    };
+    let active_param = if let Some(arg_list) = calling_node.arg_list() {
+        // Number of arguments specified at the call site
+        let num_args_at_callsite = arg_list.args().count();
+
+        let arg_list_range = arg_list.syntax().text_range();
+        if !arg_list_range.contains_inclusive(token.text_range().start()) {
+            mark::hit!(call_info_bad_offset);
+            return None;
         }
+        let param = std::cmp::min(
+            num_args_at_callsite,
+            arg_list
+                .args()
+                .take_while(|arg| arg.syntax().text_range().end() <= token.text_range().start())
+                .count(),
+        );
+
+        Some(param)
+    } else {
+        None
     };
+    Some((callable, active_param))
+}
 
-    // If we have a calling expression let's find which argument we are on
-    let num_params = signature.parameters.len();
-
-    let active_parameter = match num_params {
-        0 => None,
-        1 if signature.has_self_param => None,
-        1 => Some(0),
-        _ => {
-            if let Some(arg_list) = calling_node.arg_list() {
-                // Number of arguments specified at the call site
-                let num_args_at_callsite = arg_list.args().count();
-
-                let arg_list_range = arg_list.syntax().text_range();
-                if !arg_list_range.contains_inclusive(token.text_range().start()) {
-                    mark::hit!(call_info_bad_offset);
-                    return None;
-                }
+#[derive(Debug)]
+pub(crate) struct ActiveParameter {
+    pub(crate) ty: Type,
+    pub(crate) name: String,
+}
 
-                let mut param = std::cmp::min(
-                    num_args_at_callsite,
-                    arg_list
-                        .args()
-                        .take_while(|arg| {
-                            arg.syntax().text_range().end() <= token.text_range().start()
-                        })
-                        .count(),
-                );
-
-                // If we are in a method account for `self`
-                if signature.has_self_param {
-                    param += 1;
-                }
+impl ActiveParameter {
+    pub(crate) fn at(db: &RootDatabase, position: FilePosition) -> Option<Self> {
+        let sema = Semantics::new(db);
+        let file = sema.parse(position.file_id);
+        let file = file.syntax();
+        let token = file.token_at_offset(position.offset).next()?;
+        let token = sema.descend_into_macros(token);
+        Self::at_token(&sema, token)
+    }
 
-                Some(param)
-            } else {
-                None
-            }
-        }
-    };
+    pub(crate) fn at_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Option<Self> {
+        let (signature, active_parameter) = call_info_impl(&sema, token)?;
 
-    Some(CallInfo { signature, active_parameter })
+        let idx = active_parameter?;
+        let mut params = signature.params(sema.db);
+        let (pat, ty) = params.swap_remove(idx);
+        let name = pat?.to_string();
+        Some(ActiveParameter { ty, name })
+    }
 }
 
 #[derive(Debug)]
 pub(crate) enum FnCallNode {
     CallExpr(ast::CallExpr),
     MethodCallExpr(ast::MethodCallExpr),
-    MacroCallExpr(ast::MacroCall),
 }
 
 impl FnCallNode {
@@ -138,7 +185,6 @@ impl FnCallNode {
                         }
                         Some(FnCallNode::MethodCallExpr(it))
                     },
-                    ast::MacroCall(it) => Some(FnCallNode::MacroCallExpr(it)),
                     _ => None,
                 }
             }
@@ -150,7 +196,6 @@ impl FnCallNode {
             match node {
                 ast::CallExpr(it) => Some(FnCallNode::CallExpr(it)),
                 ast::MethodCallExpr(it) => Some(FnCallNode::MethodCallExpr(it)),
-                ast::MacroCall(it) => Some(FnCallNode::MacroCallExpr(it)),
                 _ => None,
             }
         }
@@ -166,8 +211,6 @@ impl FnCallNode {
             FnCallNode::MethodCallExpr(call_expr) => {
                 call_expr.syntax().children().filter_map(ast::NameRef::cast).next()
             }
-
-            FnCallNode::MacroCallExpr(call_expr) => call_expr.path()?.segment()?.name_ref(),
         }
     }
 
@@ -175,21 +218,10 @@ impl FnCallNode {
         match self {
             FnCallNode::CallExpr(expr) => expr.arg_list(),
             FnCallNode::MethodCallExpr(expr) => expr.arg_list(),
-            FnCallNode::MacroCallExpr(_) => None,
         }
     }
 }
 
-impl CallInfo {
-    fn into_active_parameter(self) -> Option<ActiveParameter> {
-        let idx = self.active_parameter?;
-        let ty = self.signature.parameter_types.get(idx)?.clone();
-        let name = self.signature.parameter_names.get(idx)?.clone();
-        let res = ActiveParameter { ty, name };
-        Some(res)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use expect::{expect, Expect};
@@ -202,20 +234,18 @@ mod tests {
         let call_info = analysis.call_info(position).unwrap();
         let actual = match call_info {
             Some(call_info) => {
-                let docs = match &call_info.signature.doc {
+                let docs = match &call_info.doc {
                     None => "".to_string(),
                     Some(docs) => format!("{}\n------\n", docs.as_str()),
                 };
                 let params = call_info
-                    .signature
-                    .parameters
-                    .iter()
+                    .parameter_labels()
                     .enumerate()
                     .map(|(i, param)| {
                         if Some(i) == call_info.active_parameter {
                             format!("<{}>", param)
                         } else {
-                            param.clone()
+                            param.to_string()
                         }
                     })
                     .collect::<Vec<_>>()
@@ -296,10 +326,8 @@ fn foo<T, U: Copy + Display>(x: T, y: U) -> u32
 fn bar() { foo(<|>3, ); }
 "#,
             expect![[r#"
-                fn foo<T, U: Copy + Display>(x: T, y: U) -> u32
-                where T: Copy + Display,
-                      U: Debug
-                (<x: T>, y: U)
+                fn foo(x: i32, y: {unknown}) -> u32
+                (<x: i32>, y: {unknown})
             "#]],
         );
     }
@@ -312,8 +340,7 @@ fn foo<T>() -> T where T: Copy + Display {}
 fn bar() { foo(<|>); }
 "#,
             expect![[r#"
-                fn foo<T>() -> T
-                where T: Copy + Display
+                fn foo() -> {unknown}
                 ()
             "#]],
         );
@@ -323,11 +350,14 @@ fn bar() { foo(<|>); }
     fn test_fn_signature_for_impl() {
         check(
             r#"
-struct F; impl F { pub fn new() { F{}} }
-fn bar() {let _ : F = F::new(<|>);}
+struct F;
+impl F { pub fn new() { } }
+fn bar() {
+    let _ : F = F::new(<|>);
+}
 "#,
             expect![[r#"
-                pub fn new()
+                fn new()
                 ()
             "#]],
         );
@@ -346,8 +376,8 @@ fn bar() {
 }
 "#,
             expect![[r#"
-                pub fn do_it(&self)
-                (&self)
+                fn do_it(&self)
+                ()
             "#]],
         );
     }
@@ -357,16 +387,33 @@ fn bar() {
         check(
             r#"
 struct S;
-impl S { pub fn do_it(&self, x: i32) {} }
+impl S {
+    fn foo(&self, x: i32) {}
+}
 
-fn bar() {
-    let s: S = S;
-    s.do_it(<|>);
+fn main() { S.foo(<|>); }
+"#,
+            expect![[r#"
+                fn foo(&self, x: i32)
+                (<x: i32>)
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_fn_signature_for_method_with_arg_as_assoc_fn() {
+        check(
+            r#"
+struct S;
+impl S {
+    fn foo(&self, x: i32) {}
 }
+
+fn main() { S::foo(<|>); }
 "#,
             expect![[r#"
-                pub fn do_it(&self, x: i32)
-                (&self, <x: i32>)
+                fn foo(self: &S, x: i32)
+                (<self: &S>, x: i32)
             "#]],
         );
     }
@@ -425,7 +472,7 @@ pub fn do() {
                 assert_eq!(6, my_crate::add_one(5));
                 ```
                 ------
-                pub fn add_one(x: i32) -> i32
+                fn add_one(x: i32) -> i32
                 (<x: i32>)
             "##]],
         );
@@ -467,7 +514,7 @@ pub fn do_it() {
                 assert_eq!(6, my_crate::add_one(5));
                 ```
                 ------
-                pub fn add_one(x: i32) -> i32
+                fn add_one(x: i32) -> i32
                 (<x: i32>)
             "##]],
         );
@@ -505,8 +552,8 @@ pub fn foo(mut r: WriteHandler<()>) {
 
                 By default this method stops actor's `Context`.
                 ------
-                fn finished(&mut self, ctx: &mut Self::Context)
-                (&mut self, <ctx: &mut Self::Context>)
+                fn finished(&mut self, ctx: &mut {unknown})
+                (<ctx: &mut {unknown}>)
             "#]],
         );
     }
@@ -539,7 +586,7 @@ fn main() {
 "#,
             expect![[r#"
                 fn bar(&self, _: u32)
-                (&self, <_: u32>)
+                (<_: u32>)
             "#]],
         );
     }
@@ -549,15 +596,15 @@ fn main() {
         check(
             r#"
 /// A cool tuple struct
-struct TS(u32, i32);
+struct S(u32, i32);
 fn main() {
-    let s = TS(0, <|>);
+    let s = S(0, <|>);
 }
 "#,
             expect![[r#"
                 A cool tuple struct
                 ------
-                struct TS(u32, i32) -> TS
+                struct S(u32, i32)
                 (u32, <i32>)
             "#]],
         );
@@ -567,32 +614,19 @@ fn main() {
     fn generic_struct() {
         check(
             r#"
-struct TS<T>(T);
+struct S<T>(T);
 fn main() {
-    let s = TS(<|>);
+    let s = S(<|>);
 }
 "#,
             expect![[r#"
-                struct TS<T>(T) -> TS
-                (<T>)
+                struct S({unknown})
+                (<{unknown}>)
             "#]],
         );
     }
 
     #[test]
-    fn cant_call_named_structs() {
-        check(
-            r#"
-struct TS { x: u32, y: i32 }
-fn main() {
-    let s = TS(<|>);
-}
-"#,
-            expect![[""]],
-        );
-    }
-
-    #[test]
     fn works_for_enum_variants() {
         check(
             r#"
@@ -612,27 +646,19 @@ fn main() {
             expect![[r#"
                 A Variant
                 ------
-                E::A(0: i32)
-                (<0: i32>)
+                enum E::A(i32)
+                (<i32>)
             "#]],
         );
     }
 
     #[test]
-    fn cant_call_enum_records() {
+    fn cant_call_struct_record() {
         check(
             r#"
-enum E {
-    /// A Variant
-    A(i32),
-    /// Another
-    B,
-    /// And C
-    C { a: i32, b: i32 }
-}
-
+struct S { x: u32, y: i32 }
 fn main() {
-    let a = E::C(<|>);
+    let s = S(<|>);
 }
 "#,
             expect![[""]],
@@ -640,24 +666,23 @@ fn main() {
     }
 
     #[test]
-    fn fn_signature_for_macro() {
+    fn cant_call_enum_record() {
         check(
             r#"
-/// empty macro
-macro_rules! foo {
-    () => {}
+enum E {
+    /// A Variant
+    A(i32),
+    /// Another
+    B,
+    /// And C
+    C { a: i32, b: i32 }
 }
 
-fn f() {
-    foo!(<|>);
+fn main() {
+    let a = E::C(<|>);
 }
 "#,
-            expect![[r#"
-                empty macro
-                ------
-                foo!()
-                ()
-            "#]],
+            expect![[""]],
         );
     }
 
diff --git a/crates/ra_ide/src/completion/complete_trait_impl.rs b/crates/ra_ide/src/completion/complete_trait_impl.rs
index a610fd6d1..90f5b1c25 100644
--- a/crates/ra_ide/src/completion/complete_trait_impl.rs
+++ b/crates/ra_ide/src/completion/complete_trait_impl.rs
@@ -43,7 +43,7 @@ use crate::{
     completion::{
         CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
     },
-    display::FunctionSignature,
+    display::function_signature::FunctionSignature,
 };
 
 pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext) {
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index 64349dcb8..e29b82017 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -11,7 +11,7 @@ use crate::{
         completion_item::Builder, CompletionContext, CompletionItem, CompletionItemKind,
         CompletionKind, Completions,
     },
-    display::{const_label, macro_label, type_label, FunctionSignature},
+    display::{const_label, function_signature::FunctionSignature, macro_label, type_label},
     CompletionScore, RootDatabase,
 };
 
@@ -329,15 +329,10 @@ pub(crate) fn compute_score(
     ty: &Type,
     name: &str,
 ) -> Option<CompletionScore> {
-    // FIXME: this should not fall back to string equality.
-    let ty = &ty.display(ctx.db).to_string();
     let (active_name, active_type) = if let Some(record_field) = &ctx.record_field_syntax {
         mark::hit!(record_field_type_match);
         let (struct_field, _local) = ctx.sema.resolve_record_field(record_field)?;
-        (
-            struct_field.name(ctx.db).to_string(),
-            struct_field.signature_ty(ctx.db).display(ctx.db).to_string(),
-        )
+        (struct_field.name(ctx.db).to_string(), struct_field.signature_ty(ctx.db))
     } else if let Some(active_parameter) = &ctx.active_parameter {
         mark::hit!(active_param_type_match);
         (active_parameter.name.clone(), active_parameter.ty.clone())
diff --git a/crates/ra_ide/src/display.rs b/crates/ra_ide/src/display.rs
index 70d2a2dd1..1ec946369 100644
--- a/crates/ra_ide/src/display.rs
+++ b/crates/ra_ide/src/display.rs
@@ -1,9 +1,8 @@
 //! This module contains utilities for turning SyntaxNodes and HIR types
 //! into types that may be used to render in a UI.
 
-mod function_signature;
+pub(crate) mod function_signature;
 mod navigation_target;
-mod structure;
 mod short_label;
 
 use ra_syntax::{
@@ -11,15 +10,13 @@ use ra_syntax::{
     SyntaxKind::{ATTR, COMMENT},
 };
 
-pub use function_signature::FunctionSignature;
-pub use navigation_target::NavigationTarget;
-pub use structure::{file_structure, StructureNode};
-
 pub(crate) use navigation_target::{ToNav, TryToNav};
 pub(crate) use short_label::ShortLabel;
 
+pub use navigation_target::NavigationTarget;
+
 pub(crate) fn function_label(node: &ast::FnDef) -> String {
-    FunctionSignature::from(node).to_string()
+    function_signature::FunctionSignature::from(node).to_string()
 }
 
 pub(crate) fn const_label(node: &ast::ConstDef) -> String {
diff --git a/crates/ra_ide/src/display/function_signature.rs b/crates/ra_ide/src/display/function_signature.rs
index 1d39544d3..9b7220d1f 100644
--- a/crates/ra_ide/src/display/function_signature.rs
+++ b/crates/ra_ide/src/display/function_signature.rs
@@ -15,49 +15,48 @@ use stdx::{split_delim, SepBy};
 use crate::display::{generic_parameters, where_predicates};
 
 #[derive(Debug)]
-pub enum CallableKind {
+pub(crate) enum CallableKind {
     Function,
     StructConstructor,
     VariantConstructor,
-    Macro,
 }
 
 /// Contains information about a function signature
 #[derive(Debug)]
-pub struct FunctionSignature {
-    pub kind: CallableKind,
+pub(crate) struct FunctionSignature {
+    pub(crate) kind: CallableKind,
     /// Optional visibility
-    pub visibility: Option<String>,
+    pub(crate) visibility: Option<String>,
     /// Qualifiers like `async`, `unsafe`, ...
-    pub qualifier: FunctionQualifier,
+    pub(crate) qualifier: FunctionQualifier,
     /// Name of the function
-    pub name: Option<String>,
+    pub(crate) name: Option<String>,
     /// Documentation for the function
-    pub doc: Option<Documentation>,
+    pub(crate) doc: Option<Documentation>,
     /// Generic parameters
-    pub generic_parameters: Vec<String>,
+    pub(crate) generic_parameters: Vec<String>,
     /// Parameters of the function
-    pub parameters: Vec<String>,
+    pub(crate) parameters: Vec<String>,
     /// Parameter names of the function
-    pub parameter_names: Vec<String>,
+    pub(crate) parameter_names: Vec<String>,
     /// Parameter types of the function
-    pub parameter_types: Vec<String>,
+    pub(crate) parameter_types: Vec<String>,
     /// Optional return type
-    pub ret_type: Option<String>,
+    pub(crate) ret_type: Option<String>,
     /// Where predicates
-    pub where_predicates: Vec<String>,
+    pub(crate) where_predicates: Vec<String>,
     /// Self param presence
-    pub has_self_param: bool,
+    pub(crate) has_self_param: bool,
 }
 
 #[derive(Debug, Default)]
-pub struct FunctionQualifier {
+pub(crate) struct FunctionQualifier {
     // `async` and `const` are mutually exclusive. Do we need to enforcing it here?
-    pub is_async: bool,
-    pub is_const: bool,
-    pub is_unsafe: bool,
+    pub(crate) is_async: bool,
+    pub(crate) is_const: bool,
+    pub(crate) is_unsafe: bool,
     /// The string `extern ".."`
-    pub extern_abi: Option<String>,
+    pub(crate) extern_abi: Option<String>,
 }
 
 impl FunctionSignature {
@@ -149,27 +148,6 @@ impl FunctionSignature {
             has_self_param: false,
         })
     }
-
-    pub(crate) fn from_macro(db: &RootDatabase, macro_def: hir::MacroDef) -> Option<Self> {
-        let node: ast::MacroCall = macro_def.source(db).value;
-
-        let params = vec![];
-
-        Some(FunctionSignature {
-            kind: CallableKind::Macro,
-            visibility: None,
-            qualifier: Default::default(),
-            name: node.name().map(|n| n.text().to_string()),
-            ret_type: None,
-            parameters: params,
-            parameter_names: vec![],
-            parameter_types: vec![],
-            generic_parameters: vec![],
-            where_predicates: vec![],
-            doc: macro_def.docs(db),
-            has_self_param: false,
-        })
-    }
 }
 
 impl From<&'_ ast::FnDef> for FunctionSignature {
@@ -298,7 +276,6 @@ impl Display for FunctionSignature {
                 CallableKind::Function => write!(f, "fn {}", name)?,
                 CallableKind::StructConstructor => write!(f, "struct {}", name)?,
                 CallableKind::VariantConstructor => write!(f, "{}", name)?,
-                CallableKind::Macro => write!(f, "{}!", name)?,
             }
         }
 
diff --git a/crates/ra_ide/src/display/structure.rs b/crates/ra_ide/src/file_structure.rs
index 1f6a3febf..1f6a3febf 100644
--- a/crates/ra_ide/src/display/structure.rs
+++ b/crates/ra_ide/src/file_structure.rs
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 3cbae8a45..ae5695f61 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -5,10 +5,10 @@ use ra_syntax::{
     ast::{self, ArgListOwner, AstNode, TypeAscriptionOwner},
     match_ast, Direction, NodeOrToken, SmolStr, SyntaxKind, TextRange, T,
 };
-
-use crate::{FileId, FunctionSignature};
 use stdx::to_lower_snake_case;
 
+use crate::{display::function_signature::FunctionSignature, FileId};
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct InlayHintsConfig {
     pub type_hints: bool,
@@ -322,15 +322,15 @@ fn get_fn_signature(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<
     match expr {
         ast::Expr::CallExpr(expr) => {
             // FIXME: Type::as_callable is broken for closures
-            let callable_def = sema.type_of_expr(&expr.expr()?)?.as_callable()?;
-            match callable_def {
-                hir::CallableDefId::FunctionId(it) => {
+            let callable = sema.type_of_expr(&expr.expr()?)?.as_callable(sema.db)?;
+            match callable.kind() {
+                hir::CallableKind::Function(it) => {
                     Some(FunctionSignature::from_hir(sema.db, it.into()))
                 }
-                hir::CallableDefId::StructId(it) => {
+                hir::CallableKind::TupleStruct(it) => {
                     FunctionSignature::from_struct(sema.db, it.into())
                 }
-                hir::CallableDefId::EnumVariantId(it) => {
+                hir::CallableKind::TupleEnumVariant(it) => {
                     FunctionSignature::from_enum_variant(sema.db, it.into())
                 }
             }
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 5d1f64e19..d3b20f371 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -19,29 +19,31 @@ pub mod mock_analysis;
 
 mod markup;
 mod prime_caches;
-mod status;
+mod display;
+
+mod call_hierarchy;
+mod call_info;
 mod completion;
-mod runnables;
+mod diagnostics;
+mod expand_macro;
+mod extend_selection;
+mod file_structure;
+mod folding_ranges;
 mod goto_definition;
-mod goto_type_definition;
 mod goto_implementation;
-mod extend_selection;
+mod goto_type_definition;
 mod hover;
-mod call_hierarchy;
-mod call_info;
-mod syntax_highlighting;
+mod inlay_hints;
+mod join_lines;
+mod matching_brace;
 mod parent_module;
 mod references;
-mod diagnostics;
+mod runnables;
+mod ssr;
+mod status;
+mod syntax_highlighting;
 mod syntax_tree;
-mod folding_ranges;
-mod join_lines;
 mod typing;
-mod matching_brace;
-mod display;
-mod inlay_hints;
-mod expand_macro;
-mod ssr;
 
 use std::sync::Arc;
 
@@ -65,8 +67,9 @@ pub use crate::{
         CompletionConfig, CompletionItem, CompletionItemKind, CompletionScore, InsertTextFormat,
     },
     diagnostics::Severity,
-    display::{file_structure, FunctionSignature, NavigationTarget, StructureNode},
+    display::NavigationTarget,
     expand_macro::ExpandedMacro,
+    file_structure::StructureNode,
     folding_ranges::{Fold, FoldKind},
     hover::{HoverAction, HoverConfig, HoverGotoTypeData, HoverResult},
     inlay_hints::{InlayHint, InlayHintsConfig, InlayKind},
@@ -323,7 +326,7 @@ impl Analysis {
     /// Returns a tree representation of symbols in the file. Useful to draw a
     /// file outline.
     pub fn file_structure(&self, file_id: FileId) -> Cancelable<Vec<StructureNode>> {
-        self.with_db(|db| file_structure(&db.parse(file_id).tree()))
+        self.with_db(|db| file_structure::file_structure(&db.parse(file_id).tree()))
     }
 
     /// Returns a list of the places in the file where type hints can be displayed.