32 files changed, 821 insertions, 886 deletions
diff --git a/Cargo.lock b/Cargo.lock
index cde82397c..451ba1f42 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -709,9 +709,9 @@ dependencies = [
 [[package]]
 name = "log"
-version = "0.4.8"
+version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7"
+checksum = "4fabed175da42fed1fa0746b0ea71f412aa9d35e76e95e59b192c64b9dc2bf8b"
 dependencies = [
 "cfg-if",
 ]
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 9891b0785..859bdfb3b 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -1,5 +1,5 @@
 //! FIXME: write short doc here
-use std::sync::Arc;
+use std::{iter, sync::Arc};
 use arrayvec::ArrayVec;
 use either::Either;
@@ -12,6 +12,7 @@ use hir_def::{
    import_map,
    per_ns::PerNs,
    resolver::{HasResolver, Resolver},
+    src::HasSource as _,
    type_ref::{Mutability, TypeRef},
    AdtId, AssocContainerId, ConstId, DefWithBodyId, EnumId, FunctionId, GenericDefId, HasModule,
    ImplId, LocalEnumVariantId, LocalFieldId, LocalModuleId, Lookup, ModuleId, StaticId, StructId,
@@ -25,8 +26,8 @@ use hir_expand::{
 use hir_ty::{
    autoderef,
    display::{HirDisplayError, HirFormatter},
-    method_resolution, ApplicationTy, Canonical, GenericPredicate, InEnvironment, Substs,
+    method_resolution, ApplicationTy, CallableDefId, Canonical, FnSig, GenericPredicate,
-    TraitEnvironment, Ty, TyDefId, TypeCtor,
+    InEnvironment, Substs, TraitEnvironment, Ty, TyDefId, TypeCtor,
 };
 use ra_db::{CrateId, Edition, FileId};
 use ra_prof::profile;
@@ -40,7 +41,7 @@ use stdx::impl_from;
 use crate::{
    db::{DefDatabase, HirDatabase},
    has_source::HasSource,
-    CallableDefId, HirDisplay, InFile, Name,
+    HirDisplay, InFile, Name,
 };
 /// hir::Crate describes a single crate. It's the main interface with which
@@ -1168,6 +1169,12 @@ impl Type {
        Type::new(db, krate, def, ty)
    }
+    pub fn is_unit(&self) -> bool {
+        matches!(
+            self.ty.value,
+            Ty::Apply(ApplicationTy { ctor: TypeCtor::Tuple { cardinality: 0 }, .. })
+        )
+    }
    pub fn is_bool(&self) -> bool {
        matches!(self.ty.value, Ty::Apply(ApplicationTy { ctor: TypeCtor::Bool, .. }))
    }
@@ -1225,9 +1232,14 @@ impl Type {
        db.trait_solve(self.krate, goal).is_some()
    }
-    // FIXME: this method is broken, as it doesn't take closures into account.
+    pub fn as_callable(&self, db: &dyn HirDatabase) -> Option<Callable> {
-    pub fn as_callable(&self) -> Option<CallableDefId> {
+        let def = match self.ty.value {
-        Some(self.ty.value.as_callable()?.0)
+            Ty::Apply(ApplicationTy { ctor: TypeCtor::FnDef(def), parameters: _ }) => Some(def),
+            _ => None,
+        };
+        let sig = self.ty.value.callable_sig(db)?;
+        Some(Callable { ty: self.clone(), sig, def, is_bound_method: false })
    }
    pub fn is_closure(&self) -> bool {
@@ -1512,6 +1524,74 @@ impl HirDisplay for Type {
    }
 }
+// FIXME: closures
+#[derive(Debug)]
+pub struct Callable {
+    ty: Type,
+    sig: FnSig,
+    def: Option<CallableDefId>,
+    pub(crate) is_bound_method: bool,
+}
+pub enum CallableKind {
+    Function(Function),
+    TupleStruct(Struct),
+    TupleEnumVariant(EnumVariant),
+    Closure,
+}
+impl Callable {
+    pub fn kind(&self) -> CallableKind {
+        match self.def {
+            Some(CallableDefId::FunctionId(it)) => CallableKind::Function(it.into()),
+            Some(CallableDefId::StructId(it)) => CallableKind::TupleStruct(it.into()),
+            Some(CallableDefId::EnumVariantId(it)) => CallableKind::TupleEnumVariant(it.into()),
+            None => CallableKind::Closure,
+        }
+    }
+    pub fn receiver_param(&self, db: &dyn HirDatabase) -> Option<ast::SelfParam> {
+        let func = match self.def {
+            Some(CallableDefId::FunctionId(it)) if self.is_bound_method => it,
+            _ => return None,
+        };
+        let src = func.lookup(db.upcast()).source(db.upcast());
+        let param_list = src.value.param_list()?;
+        param_list.self_param()
+    }
+    pub fn n_params(&self) -> usize {
+        self.sig.params().len() - if self.is_bound_method { 1 } else { 0 }
+    }
+    pub fn params(
+        &self,
+        db: &dyn HirDatabase,
+    ) -> Vec<(Option<Either<ast::SelfParam, ast::Pat>>, Type)> {
+        let types = self
+            .sig
+            .params()
+            .iter()
+            .skip(if self.is_bound_method { 1 } else { 0 })
+            .map(|ty| self.ty.derived(ty.clone()));
+        let patterns = match self.def {
+            Some(CallableDefId::FunctionId(func)) => {
+                let src = func.lookup(db.upcast()).source(db.upcast());
+                src.value.param_list().map(|param_list| {
+                    param_list
+                        .self_param()
+                        .map(|it| Some(Either::Left(it)))
+                        .filter(|_| !self.is_bound_method)
+                        .into_iter()
+                        .chain(param_list.params().map(|it| it.pat().map(Either::Right)))
+                })
+            }
+            _ => None,
+        };
+        patterns.into_iter().flatten().chain(iter::repeat(None)).zip(types).collect()
+    }
+    pub fn return_type(&self) -> Type {
+        self.ty.derived(self.sig.ret().clone())
+    }
+}
 /// For IDE only
 #[derive(Debug)]
 pub enum ScopeDef {
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index cf7134923..31f3241c9 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -32,10 +32,10 @@ mod has_source;
 pub use crate::{
    code_model::{
-        Adt, AsAssocItem, AssocItem, AssocItemContainer, AttrDef, Const, Crate, CrateDependency,
+        Adt, AsAssocItem, AssocItem, AssocItemContainer, AttrDef, Callable, CallableKind, Const,
-        DefWithBody, Docs, Enum, EnumVariant, Field, FieldSource, Function, GenericDef, HasAttrs,
+        Crate, CrateDependency, DefWithBody, Docs, Enum, EnumVariant, Field, FieldSource, Function,
-        HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, ScopeDef, Static, Struct,
+        GenericDef, HasAttrs, HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, ScopeDef,
-        Trait, Type, TypeAlias, TypeParam, Union, VariantDef, Visibility,
+        Static, Struct, Trait, Type, TypeAlias, TypeParam, Union, VariantDef, Visibility,
    },
    has_source::HasSource,
    semantics::{original_range, PathResolution, Semantics, SemanticsScope},
@@ -52,7 +52,8 @@ pub use hir_def::{
    type_ref::Mutability,
 };
 pub use hir_expand::{
-    hygiene::Hygiene, name::Name, HirFileId, InFile, MacroCallId, MacroCallLoc, MacroDefId,
+    hygiene::Hygiene, name::Name, HirFileId, InFile, MacroCallId, MacroCallLoc,
+    MacroDefId, /* FIXME */
    MacroFile, Origin,
 };
-pub use hir_ty::{display::HirDisplay, CallableDefId};
+pub use hir_ty::display::HirDisplay;
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index 155b666d7..f5283ab22 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -6,7 +6,7 @@ use std::{cell::RefCell, fmt, iter::successors};
 use hir_def::{
    resolver::{self, HasResolver, Resolver},
-    AsMacroCall, TraitId, VariantId,
+    AsMacroCall, FunctionId, TraitId, VariantId,
 };
 use hir_expand::{diagnostics::AstDiagnostic, hygiene::Hygiene, ExpansionInfo};
 use hir_ty::associated_type_shorthand_candidates;
@@ -24,8 +24,8 @@ use crate::{
    diagnostics::Diagnostic,
    semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx},
    source_analyzer::{resolve_hir_path, resolve_hir_path_qualifier, SourceAnalyzer},
-    AssocItem, Field, Function, HirFileId, ImplDef, InFile, Local, MacroDef, Module, ModuleDef,
+    AssocItem, Callable, Field, Function, HirFileId, ImplDef, InFile, Local, MacroDef, Module,
-    Name, Origin, Path, ScopeDef, Trait, Type, TypeAlias, TypeParam, VariantDef,
+    ModuleDef, Name, Origin, Path, ScopeDef, Trait, Type, TypeAlias, TypeParam, VariantDef,
 };
 use resolver::TypeNs;
@@ -197,7 +197,11 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
    }
    pub fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
-        self.imp.resolve_method_call(call)
+        self.imp.resolve_method_call(call).map(Function::from)
+    }
+    pub fn resolve_method_call_as_callable(&self, call: &ast::MethodCallExpr) -> Option<Callable> {
+        self.imp.resolve_method_call_as_callable(call)
    }
    pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option<Field> {
@@ -385,10 +389,21 @@ impl<'db> SemanticsImpl<'db> {
        self.analyze(param.syntax()).type_of_self(self.db, &param)
    }
-    fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
+    fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<FunctionId> {
        self.analyze(call.syntax()).resolve_method_call(self.db, call)
    }
+    fn resolve_method_call_as_callable(&self, call: &ast::MethodCallExpr) -> Option<Callable> {
+        // FIXME: this erases Substs
+        let func = self.resolve_method_call(call)?;
+        let ty = self.db.value_ty(func.into());
+        let resolver = self.analyze(call.syntax()).resolver;
+        let ty = Type::new_with_resolver(self.db, &resolver, ty.value)?;
+        let mut res = ty.as_callable(self.db)?;
+        res.is_bound_method = true;
+        Some(res)
+    }
    fn resolve_field(&self, field: &ast::FieldExpr) -> Option<Field> {
        self.analyze(field.syntax()).resolve_field(self.db, field)
    }
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index ecb54f653..86a47a9e5 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -14,7 +14,7 @@ use hir_def::{
    },
    expr::{ExprId, Pat, PatId},
    resolver::{resolver_for_scope, Resolver, TypeNs, ValueNs},
-    AsMacroCall, DefWithBodyId, FieldId, LocalFieldId, VariantId,
+    AsMacroCall, DefWithBodyId, FieldId, FunctionId, LocalFieldId, VariantId,
 };
 use hir_expand::{hygiene::Hygiene, name::AsName, HirFileId, InFile};
 use hir_ty::{
@@ -142,9 +142,9 @@ impl SourceAnalyzer {
        &self,
        db: &dyn HirDatabase,
        call: &ast::MethodCallExpr,
-    ) -> Option<Function> {
+    ) -> Option<FunctionId> {
        let expr_id = self.expr_id(db, &call.clone().into())?;
-        self.infer.as_ref()?.method_resolution(expr_id).map(Function::from)
+        self.infer.as_ref()?.method_resolution(expr_id)
    }
    pub(crate) fn resolve_field(
diff --git a/crates/ra_hir_def/src/nameres/path_resolution.rs b/crates/ra_hir_def/src/nameres/path_resolution.rs
index 19692e70c..dbfa7fccb 100644
--- a/crates/ra_hir_def/src/nameres/path_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/path_resolution.rs
@@ -226,7 +226,15 @@ impl CrateDefMap {
                    match enum_data.variant(&segment) {
                        Some(local_id) => {
                            let variant = EnumVariantId { parent: e, local_id };
-                            PerNs::both(variant.into(), variant.into(), Visibility::Public)
+                            match &*enum_data.variants[local_id].variant_data {
+                                crate::adt::VariantData::Record(_) => {
+                                    PerNs::types(variant.into(), Visibility::Public)
+                                }
+                                crate::adt::VariantData::Tuple(_)
+                                | crate::adt::VariantData::Unit => {
+                                    PerNs::both(variant.into(), variant.into(), Visibility::Public)
+                                }
+                            }
                        }
                        None => {
                            return ResolvePathResult::with(
diff --git a/crates/ra_hir_ty/src/diagnostics/expr.rs b/crates/ra_hir_ty/src/diagnostics/expr.rs
index 557d01cdc..fd930eab1 100644
--- a/crates/ra_hir_ty/src/diagnostics/expr.rs
+++ b/crates/ra_hir_ty/src/diagnostics/expr.rs
@@ -158,28 +158,32 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        }
        let is_method_call = matches!(expr, Expr::MethodCall { .. });
-        let (callee, args) = match expr {
+        let (sig, args) = match expr {
            Expr::Call { callee, args } => {
                let callee = &self.infer.type_of_expr[*callee];
-                let (callable, _) = callee.as_callable()?;
+                let sig = callee.callable_sig(db)?;
+                (sig, args.clone())
-                (callable, args.clone())
            }
            Expr::MethodCall { receiver, args, .. } => {
-                let callee = self.infer.method_resolution(call_id)?;
                let mut args = args.clone();
                args.insert(0, *receiver);
-                (callee.into(), args)
+                // FIXME: note that we erase information about substs here. This
+                // is not right, but, luckily, doesn't matter as we care only
+                // about the number of params
+                let callee = self.infer.method_resolution(call_id)?;
+                let sig = db.callable_item_signature(callee.into()).value;
+                (sig, args)
            }
            _ => return None,
        };
-        let sig = db.callable_item_signature(callee);
+        if sig.is_varargs {
-        if sig.value.is_varargs {
            return None;
        }
-        let params = sig.value.params();
+        let params = sig.params();
        let mut param_count = params.len();
        let mut arg_count = args.len();
@@ -542,4 +546,20 @@ fn f() {
        "#,
        )
    }
+    #[test]
+    fn arg_count_lambda() {
+        check_diagnostics(
+            r#"
+fn main() {
+    let f = |()| ();
+    f();
+  //^^^ Expected 1 argument, found 0
+    f(());
+    f((), ());
+  //^^^^^^^^^ Expected 1 argument, found 2
+}
+"#,
+        )
+    }
 }
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index 0ef5ca78f..7698cb0d4 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -767,15 +767,6 @@ impl Ty {
        }
    }
-    pub fn as_callable(&self) -> Option<(CallableDefId, &Substs)> {
-        match self {
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::FnDef(callable_def), parameters }) => {
-                Some((*callable_def, parameters))
-            }
-            _ => None,
-        }
-    }
    pub fn is_never(&self) -> bool {
        matches!(self, Ty::Apply(ApplicationTy { ctor: TypeCtor::Never, .. }))
    }
@@ -807,7 +798,7 @@ impl Ty {
        }
    }
-    fn callable_sig(&self, db: &dyn HirDatabase) -> Option<FnSig> {
+    pub fn callable_sig(&self, db: &dyn HirDatabase) -> Option<FnSig> {
        match self {
            Ty::Apply(a_ty) => match a_ty.ctor {
                TypeCtor::FnPtr { is_varargs, .. } => {
diff --git a/crates/ra_ide/src/call_hierarchy.rs b/crates/ra_ide/src/call_hierarchy.rs
index cb7e62cd6..c28af8ab3 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()?;
+                    let callable = sema.type_of_expr(&expr.expr()?)?.as_callable(db)?;
-                    match callable_def {
+                    match callable.kind() {
-                        hir::CallableDefId::FunctionId(it) => {
+                        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 {
@@ -158,7 +154,8 @@ mod tests {
        let nav = navs.pop().unwrap();
        nav.assert_match(expected);
-        let item_pos = FilePosition { file_id: nav.file_id(), offset: nav.range().start() };
+        let item_pos =
+            FilePosition { file_id: nav.file_id, offset: nav.focus_or_full_range().start() };
        let incoming_calls = analysis.incoming_calls(item_pos).unwrap().unwrap();
        assert_eq!(incoming_calls.len(), expected_incoming.len());
diff --git a/crates/ra_ide/src/call_info.rs b/crates/ra_ide/src/call_info.rs
index 1fe1c21de..14980afdd 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,131 @@ 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)]
+    let (callable, active_parameter) = call_info_impl(&sema, token)?;
-pub(crate) struct ActiveParameter {
-    /// FIXME: should be `Type` and `Name
-    pub(crate) ty: String,
-    pub(crate) name: String,
-}
-impl ActiveParameter {
+    let mut res =
-    pub(crate) fn at(db: &RootDatabase, position: FilePosition) -> Option<Self> {
+        CallInfo { doc: None, signature: String::new(), parameters: vec![], active_parameter };
-        call_info(db, position)?.into_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)
+            );
+        }
+        hir::CallableKind::Closure => (),
    }
-    pub(crate) fn at_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Option<Self> {
+    res.signature.push('(');
-        call_info_for_token(sema, token)?.into_active_parameter()
+    {
+        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(_) | hir::CallableKind::Closure => {
+            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 {
+    let callable = match &calling_node {
-        FnCallNode::CallExpr(call) => {
+        FnCallNode::CallExpr(call) => sema.type_of_expr(&call.expr()?)?.as_callable(sema.db)?,
-            //FIXME: Type::as_callable is broken
+        FnCallNode::MethodCallExpr(call) => sema.resolve_method_call_as_callable(call)?,
-            let callable_def = sema.type_of_expr(&call.expr()?)?.as_callable()?;
+    };
-            match callable_def {
+    let active_param = if let Some(arg_list) = calling_node.arg_list() {
-                hir::CallableDefId::FunctionId(it) => {
+        // Number of arguments specified at the call site
-                    let fn_def = it.into();
+        let num_args_at_callsite = arg_list.args().count();
-                    FunctionSignature::from_hir(sema.db, fn_def)
-                }
+        let arg_list_range = arg_list.syntax().text_range();
-                hir::CallableDefId::StructId(it) => {
+        if !arg_list_range.contains_inclusive(token.text_range().start()) {
-                    FunctionSignature::from_struct(sema.db, it.into())?
+            mark::hit!(call_info_bad_offset);
-                }
+            return None;
-                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 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
+#[derive(Debug)]
-    let num_params = signature.parameters.len();
+pub(crate) struct ActiveParameter {
+    pub(crate) ty: Type,
-    let active_parameter = match num_params {
+    pub(crate) name: String,
-        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;
-                }
-                let mut param = std::cmp::min(
+impl ActiveParameter {
-                    num_args_at_callsite,
+    pub(crate) fn at(db: &RootDatabase, position: FilePosition) -> Option<Self> {
-                    arg_list
+        let sema = Semantics::new(db);
-                        .args()
+        let file = sema.parse(position.file_id);
-                        .take_while(|arg| {
+        let file = file.syntax();
-                            arg.syntax().text_range().end() <= token.text_range().start()
+        let token = file.token_at_offset(position.offset).next()?;
-                        })
+        let token = sema.descend_into_macros(token);
-                        .count(),
+        Self::at_token(&sema, token)
-                );
+    }
-                // If we are in a method account for `self`
-                if signature.has_self_param {
-                    param += 1;
-                }
-                Some(param)
+    pub(crate) fn at_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Option<Self> {
-            } else {
+        let (signature, active_parameter) = call_info_impl(&sema, token)?;
-                None
-            }
-        }
-    };
-    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 +186,6 @@ impl FnCallNode {
                        }
                        Some(FnCallNode::MethodCallExpr(it))
                    },
-                    ast::MacroCall(it) => Some(FnCallNode::MacroCallExpr(it)),
                    _ => None,
                }
            }
@@ -150,7 +197,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 +212,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 +219,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 +235,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
+                    .parameter_labels()
-                    .parameters
-                    .iter()
                    .enumerate()
                    .map(|(i, param)| {
                        if Some(i) == call_info.active_parameter {
                            format!("<{}>", param)
                        } else {
-                            param.clone()
+                            param.to_string()
                        }
                    })
                    .collect::<Vec<_>>()
@@ -296,10 +327,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
+                fn foo(x: i32, y: {unknown}) -> u32
-                where T: Copy + Display,
+                (<x: i32>, y: {unknown})
-                      U: Debug
-                (<x: T>, y: U)
            "#]],
        );
    }
@@ -312,8 +341,7 @@ fn foo<T>() -> T where T: Copy + Display {}
 fn bar() { foo(<|>); }
 "#,
            expect![[r#"
-                fn foo<T>() -> T
+                fn foo() -> {unknown}
-                where T: Copy + Display
                ()
            "#]],
        );
@@ -323,11 +351,14 @@ fn bar() { foo(<|>); }
    fn test_fn_signature_for_impl() {
        check(
            r#"
-struct F; impl F { pub fn new() { F{}} }
+struct F;
-fn bar() {let _ : F = F::new(<|>);}
+impl F { pub fn new() { } }
+fn bar() {
+    let _ : F = F::new(<|>);
+}
 "#,
            expect![[r#"
-                pub fn new()
+                fn new()
                ()
            "#]],
        );
@@ -346,8 +377,8 @@ fn bar() {
 }
 "#,
            expect![[r#"
-                pub fn do_it(&self)
+                fn do_it(&self)
-                (&self)
+                ()
            "#]],
        );
    }
@@ -357,16 +388,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() {
+fn main() { S.foo(<|>); }
-    let s: S = S;
+"#,
-    s.do_it(<|>);
+            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)
+                fn foo(self: &S, x: i32)
-                (&self, <x: i32>)
+                (<self: &S>, x: i32)
            "#]],
        );
    }
@@ -425,7 +473,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 +515,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 +553,8 @@ pub fn foo(mut r: WriteHandler<()>) {
                By default this method stops actor's `Context`.
                ------
-                fn finished(&mut self, ctx: &mut Self::Context)
+                fn finished(&mut self, ctx: &mut {unknown})
-                (&mut self, <ctx: &mut Self::Context>)
+                (<ctx: &mut {unknown}>)
            "#]],
        );
    }
@@ -539,7 +587,7 @@ fn main() {
 "#,
            expect![[r#"
                fn bar(&self, _: u32)
-                (&self, <_: u32>)
+                (<_: u32>)
            "#]],
        );
    }
@@ -549,15 +597,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 +615,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
+                struct S({unknown})
-                (<T>)
+                (<{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,14 +647,27 @@ fn main() {
            expect![[r#"
                A Variant
                ------
-                E::A(0: i32)
+                enum E::A(i32)
-                (<0: i32>)
+                (<i32>)
            "#]],
        );
    }
    #[test]
-    fn cant_call_enum_records() {
+    fn cant_call_struct_record() {
+        check(
+            r#"
+struct S { x: u32, y: i32 }
+fn main() {
+    let s = S(<|>);
+}
+"#,
+            expect![[""]],
+        );
+    }
+    #[test]
+    fn cant_call_enum_record() {
        check(
            r#"
 enum E {
@@ -640,41 +688,51 @@ fn main() {
    }
    #[test]
-    fn fn_signature_for_macro() {
+    fn fn_signature_for_call_in_macro() {
        check(
            r#"
-/// empty macro
+macro_rules! id { ($($tt:tt)*) => { $($tt)* } }
-macro_rules! foo {
+fn foo() { }
-    () => {}
+id! {
-}
+    fn bar() { foo(<|>); }
-fn f() {
-    foo!(<|>);
 }
 "#,
            expect![[r#"
-                empty macro
+                fn foo()
-                ------
-                foo!()
                ()
            "#]],
        );
    }
    #[test]
-    fn fn_signature_for_call_in_macro() {
+    fn call_info_for_lambdas() {
        check(
            r#"
-macro_rules! id { ($($tt:tt)*) => { $($tt)* } }
+struct S;
-fn foo() { }
+fn foo(s: S) -> i32 { 92 }
-id! {
+fn main() {
-    fn bar() { foo(<|>); }
+    (|s| foo(s))(<|>)
 }
-"#,
+        "#,
            expect![[r#"
-                fn foo()
+                (S) -> i32
-                ()
+                (<S>)
            "#]],
-        );
+        )
+    }
+    #[test]
+    fn call_info_for_fn_ptr() {
+        check(
+            r#"
+fn main(f: fn(i32, f64) -> char) {
+    f(0, <|>)
+}
+        "#,
+            expect![[r#"
+                (i32, f64) -> char
+                (i32, <f64>)
+            "#]],
+        )
    }
 }
diff --git a/crates/ra_ide/src/completion/complete_trait_impl.rs b/crates/ra_ide/src/completion/complete_trait_impl.rs
index a610fd6d1..cf716540f 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_declaration,
 };
 pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext) {
@@ -125,8 +125,6 @@ fn add_function_impl(
    ctx: &CompletionContext,
    func: hir::Function,
 ) {
-    let signature = FunctionSignature::from_hir(ctx.db, func);
    let fn_name = func.name(ctx.db).to_string();
    let label = if !func.params(ctx.db).is_empty() {
@@ -146,13 +144,14 @@ fn add_function_impl(
    };
    let range = TextRange::new(fn_def_node.text_range().start(), ctx.source_range().end());
+    let function_decl = function_declaration(&func.source(ctx.db).value);
    match ctx.config.snippet_cap {
        Some(cap) => {
-            let snippet = format!("{} {{\n    $0\n}}", signature);
+            let snippet = format!("{} {{\n    $0\n}}", function_decl);
            builder.snippet_edit(cap, TextEdit::replace(range, snippet))
        }
        None => {
-            let header = format!("{} {{", signature);
+            let header = format!("{} {{", function_decl);
            builder.text_edit(TextEdit::replace(range, header))
        }
    }
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index 64349dcb8..c7b74e635 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_declaration, macro_label, type_label},
    CompletionScore, RootDatabase,
 };
@@ -195,7 +195,6 @@ impl Completions {
        let name = local_name.unwrap_or_else(|| func.name(ctx.db).to_string());
        let ast_node = func.source(ctx.db).value;
-        let function_signature = FunctionSignature::from(&ast_node);
        let mut builder =
            CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.clone())
@@ -206,13 +205,14 @@ impl Completions {
                })
                .set_documentation(func.docs(ctx.db))
                .set_deprecated(is_deprecated(func, ctx.db))
-                .detail(function_signature.to_string());
+                .detail(function_declaration(&ast_node));
-        let params = function_signature
+        let params = ast_node
-            .parameter_names
+            .param_list()
-            .iter()
+            .into_iter()
-            .skip(if function_signature.has_self_param { 1 } else { 0 })
+            .flat_map(|it| it.params())
-            .map(|name| name.trim_start_matches('_').into())
+            .flat_map(|it| it.pat())
+            .map(|pat| pat.to_string().trim_start_matches('_').into())
            .collect();
        builder = builder.add_call_parens(ctx, name, Params::Named(params));
@@ -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))
-            struct_field.name(ctx.db).to_string(),
-            struct_field.signature_ty(ctx.db).display(ctx.db).to_string(),
-        )
    } 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..6d4151dd8 100644
--- a/crates/ra_ide/src/display.rs
+++ b/crates/ra_ide/src/display.rs
@@ -1,9 +1,7 @@
 //! This module contains utilities for turning SyntaxNodes and HIR types
 //! into types that may be used to render in a UI.
-mod function_signature;
 mod navigation_target;
-mod structure;
 mod short_label;
 use ra_syntax::{
@@ -11,15 +9,49 @@ use ra_syntax::{
    SyntaxKind::{ATTR, COMMENT},
 };
-pub use function_signature::FunctionSignature;
+use ast::VisibilityOwner;
-pub use navigation_target::NavigationTarget;
+use stdx::format_to;
-pub use structure::{file_structure, StructureNode};
+pub use navigation_target::NavigationTarget;
 pub(crate) use navigation_target::{ToNav, TryToNav};
 pub(crate) use short_label::ShortLabel;
-pub(crate) fn function_label(node: &ast::FnDef) -> String {
+pub(crate) fn function_declaration(node: &ast::FnDef) -> String {
-    FunctionSignature::from(node).to_string()
+    let mut buf = String::new();
+    if let Some(vis) = node.visibility() {
+        format_to!(buf, "{} ", vis);
+    }
+    if node.async_token().is_some() {
+        format_to!(buf, "async ");
+    }
+    if node.const_token().is_some() {
+        format_to!(buf, "const ");
+    }
+    if node.unsafe_token().is_some() {
+        format_to!(buf, "unsafe ");
+    }
+    if let Some(abi) = node.abi() {
+        // Keyword `extern` is included in the string.
+        format_to!(buf, "{} ", abi);
+    }
+    if let Some(name) = node.name() {
+        format_to!(buf, "fn {}", name)
+    }
+    if let Some(type_params) = node.type_param_list() {
+        format_to!(buf, "{}", type_params);
+    }
+    if let Some(param_list) = node.param_list() {
+        format_to!(buf, "{}", param_list);
+    }
+    if let Some(ret_type) = node.ret_type() {
+        if ret_type.type_ref().is_some() {
+            format_to!(buf, " {}", ret_type);
+        }
+    }
+    if let Some(where_clause) = node.where_clause() {
+        format_to!(buf, "\n{}", where_clause);
+    }
+    buf
 }
 pub(crate) fn const_label(node: &ast::ConstDef) -> String {
@@ -44,23 +76,6 @@ pub(crate) fn type_label(node: &ast::TypeAliasDef) -> String {
    label.trim().to_owned()
 }
-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
-}
 pub(crate) fn macro_label(node: &ast::MacroCall) -> String {
    let name = node.name().map(|name| name.syntax().text().to_string()).unwrap_or_default();
    let vis = if node.has_atom_attr("macro_export") { "#[macro_export]\n" } else { "" };
diff --git a/crates/ra_ide/src/display/function_signature.rs b/crates/ra_ide/src/display/function_signature.rs
deleted file mode 100644
index 1d39544d3..000000000
--- a/crates/ra_ide/src/display/function_signature.rs
+++ /dev/null
@@ -1,321 +0,0 @@
-//! FIXME: write short doc here
-// FIXME: this modules relies on strings and AST way too much, and it should be
-// rewritten (matklad 2020-05-07)
-use std::{
-    convert::From,
-    fmt::{self, Display},
-};
-use hir::{Docs, Documentation, HasSource, HirDisplay};
-use ra_ide_db::RootDatabase;
-use ra_syntax::ast::{self, AstNode, NameOwner, VisibilityOwner};
-use stdx::{split_delim, SepBy};
-use crate::display::{generic_parameters, where_predicates};
-#[derive(Debug)]
-pub enum CallableKind {
-    Function,
-    StructConstructor,
-    VariantConstructor,
-    Macro,
-}
-/// Contains information about a function signature
-#[derive(Debug)]
-pub struct FunctionSignature {
-    pub kind: CallableKind,
-    /// Optional visibility
-    pub visibility: Option<String>,
-    /// Qualifiers like `async`, `unsafe`, ...
-    pub qualifier: FunctionQualifier,
-    /// Name of the function
-    pub name: Option<String>,
-    /// Documentation for the function
-    pub doc: Option<Documentation>,
-    /// Generic parameters
-    pub generic_parameters: Vec<String>,
-    /// Parameters of the function
-    pub parameters: Vec<String>,
-    /// Parameter names of the function
-    pub parameter_names: Vec<String>,
-    /// Parameter types of the function
-    pub parameter_types: Vec<String>,
-    /// Optional return type
-    pub ret_type: Option<String>,
-    /// Where predicates
-    pub where_predicates: Vec<String>,
-    /// Self param presence
-    pub has_self_param: bool,
-}
-#[derive(Debug, Default)]
-pub 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,
-    /// The string `extern ".."`
-    pub extern_abi: Option<String>,
-}
-impl FunctionSignature {
-    pub(crate) fn from_hir(db: &RootDatabase, function: hir::Function) -> Self {
-        let ast_node = function.source(db).value;
-        let mut res = FunctionSignature::from(&ast_node);
-        res.doc = function.docs(db);
-        res
-    }
-    pub(crate) fn from_struct(db: &RootDatabase, st: hir::Struct) -> Option<Self> {
-        let node: ast::StructDef = st.source(db).value;
-        if let ast::StructKind::Record(_) = node.kind() {
-            return None;
-        };
-        let mut params = vec![];
-        let mut parameter_types = vec![];
-        for field in st.fields(db).into_iter() {
-            let ty = field.signature_ty(db);
-            let raw_param = format!("{}", ty.display(db));
-            if let Some(param_type) = raw_param.split(':').nth(1).and_then(|it| it.get(1..)) {
-                parameter_types.push(param_type.to_string());
-            } else {
-                // useful when you have tuple struct
-                parameter_types.push(raw_param.clone());
-            }
-            params.push(raw_param);
-        }
-        Some(FunctionSignature {
-            kind: CallableKind::StructConstructor,
-            visibility: node.visibility().map(|n| n.syntax().text().to_string()),
-            // Do we need `const`?
-            qualifier: Default::default(),
-            name: node.name().map(|n| n.text().to_string()),
-            ret_type: node.name().map(|n| n.text().to_string()),
-            parameters: params,
-            parameter_names: vec![],
-            parameter_types,
-            generic_parameters: generic_parameters(&node),
-            where_predicates: where_predicates(&node),
-            doc: st.docs(db),
-            has_self_param: false,
-        })
-    }
-    pub(crate) fn from_enum_variant(db: &RootDatabase, variant: hir::EnumVariant) -> Option<Self> {
-        let node: ast::EnumVariant = variant.source(db).value;
-        match node.kind() {
-            ast::StructKind::Record(_) | ast::StructKind::Unit => return None,
-            _ => (),
-        };
-        let parent_name = variant.parent_enum(db).name(db).to_string();
-        let name = format!("{}::{}", parent_name, variant.name(db));
-        let mut params = vec![];
-        let mut parameter_types = vec![];
-        for field in variant.fields(db).into_iter() {
-            let ty = field.signature_ty(db);
-            let raw_param = format!("{}", ty.display(db));
-            if let Some(param_type) = raw_param.split(':').nth(1).and_then(|it| it.get(1..)) {
-                parameter_types.push(param_type.to_string());
-            } else {
-                // The unwrap_or_else is useful when you have tuple
-                parameter_types.push(raw_param);
-            }
-            let name = field.name(db);
-            params.push(format!("{}: {}", name, ty.display(db)));
-        }
-        Some(FunctionSignature {
-            kind: CallableKind::VariantConstructor,
-            visibility: None,
-            // Do we need `const`?
-            qualifier: Default::default(),
-            name: Some(name),
-            ret_type: None,
-            parameters: params,
-            parameter_names: vec![],
-            parameter_types,
-            generic_parameters: vec![],
-            where_predicates: vec![],
-            doc: variant.docs(db),
-            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 {
-    fn from(node: &ast::FnDef) -> FunctionSignature {
-        fn param_list(node: &ast::FnDef) -> (bool, Vec<String>, Vec<String>) {
-            let mut res = vec![];
-            let mut res_types = vec![];
-            let mut has_self_param = false;
-            if let Some(param_list) = node.param_list() {
-                if let Some(self_param) = param_list.self_param() {
-                    has_self_param = true;
-                    let raw_param = self_param.syntax().text().to_string();
-                    res_types.push(
-                        raw_param
-                            .split(':')
-                            .nth(1)
-                            .and_then(|it| it.get(1..))
-                            .unwrap_or_else(|| "Self")
-                            .to_string(),
-                    );
-                    res.push(raw_param);
-                }
-                // macro-generated functions are missing whitespace
-                fn fmt_param(param: ast::Param) -> String {
-                    let text = param.syntax().text().to_string();
-                    match split_delim(&text, ':') {
-                        Some((left, right)) => format!("{}: {}", left.trim(), right.trim()),
-                        _ => text,
-                    }
-                }
-                res.extend(param_list.params().map(fmt_param));
-                res_types.extend(param_list.params().map(|param| {
-                    let param_text = param.syntax().text().to_string();
-                    match param_text.split(':').nth(1).and_then(|it| it.get(1..)) {
-                        Some(it) => it.to_string(),
-                        None => param_text,
-                    }
-                }));
-            }
-            (has_self_param, res, res_types)
-        }
-        fn param_name_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| {
-                            Some(
-                                param
-                                    .pat()?
-                                    .syntax()
-                                    .descendants()
-                                    .find_map(ast::Name::cast)?
-                                    .text()
-                                    .to_string(),
-                            )
-                        })
-                        .map(|param| param.unwrap_or_default()),
-                );
-            }
-            res
-        }
-        let (has_self_param, parameters, parameter_types) = param_list(node);
-        FunctionSignature {
-            kind: CallableKind::Function,
-            visibility: node.visibility().map(|n| n.syntax().text().to_string()),
-            qualifier: FunctionQualifier {
-                is_async: node.async_token().is_some(),
-                is_const: node.const_token().is_some(),
-                is_unsafe: node.unsafe_token().is_some(),
-                extern_abi: node.abi().map(|n| n.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,
-            parameter_names: param_name_list(node),
-            parameter_types,
-            generic_parameters: generic_parameters(node),
-            where_predicates: where_predicates(node),
-            // docs are processed separately
-            doc: None,
-            has_self_param,
-        }
-    }
-}
-impl Display for FunctionSignature {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if let Some(t) = &self.visibility {
-            write!(f, "{} ", t)?;
-        }
-        if self.qualifier.is_async {
-            write!(f, "async ")?;
-        }
-        if self.qualifier.is_const {
-            write!(f, "const ")?;
-        }
-        if self.qualifier.is_unsafe {
-            write!(f, "unsafe ")?;
-        }
-        if let Some(extern_abi) = &self.qualifier.extern_abi {
-            // Keyword `extern` is included in the string.
-            write!(f, "{} ", extern_abi)?;
-        }
-        if let Some(name) = &self.name {
-            match self.kind {
-                CallableKind::Function => write!(f, "fn {}", name)?,
-                CallableKind::StructConstructor => write!(f, "struct {}", name)?,
-                CallableKind::VariantConstructor => write!(f, "{}", name)?,
-                CallableKind::Macro => write!(f, "{}!", name)?,
-            }
-        }
-        if !self.generic_parameters.is_empty() {
-            write!(f, "{}", self.generic_parameters.iter().sep_by(", ").surround_with("<", ">"))?;
-        }
-        write!(f, "{}", self.parameters.iter().sep_by(", ").surround_with("(", ")"))?;
-        if let Some(t) = &self.ret_type {
-            write!(f, " -> {}", t)?;
-        }
-        if !self.where_predicates.is_empty() {
-            write!(f, "\nwhere {}", self.where_predicates.iter().sep_by(",\n      "))?;
-        }
-        Ok(())
-    }
-}
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs
index 8bf2428ed..6dcb9415a 100644
--- a/crates/ra_ide/src/display/navigation_target.rs
+++ b/crates/ra_ide/src/display/navigation_target.rs
@@ -22,15 +22,28 @@ use super::short_label::ShortLabel;
 /// code, like a function or a struct, but this is not strictly required.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct NavigationTarget {
-    // FIXME: use FileRange?
+    pub file_id: FileId,
-    file_id: FileId,
+    /// Range which encompasses the whole element.
-    full_range: TextRange,
+    ///
-    name: SmolStr,
+    /// Should include body, doc comments, attributes, etc.
-    kind: SyntaxKind,
+    ///
-    focus_range: Option<TextRange>,
+    /// Clients should use this range to answer "is the cursor inside the
-    container_name: Option<SmolStr>,
+    /// element?" question.
-    description: Option<String>,
+    pub full_range: TextRange,
-    docs: Option<String>,
+    /// A "most interesting" range withing the `full_range`.
+    ///
+    /// Typically, `full_range` is the whole syntax node, including doc
+    /// comments, and `focus_range` is the range of the identifier. "Most
+    /// interesting" range within the full range, typically the range of
+    /// identifier.
+    ///
+    /// Clients should place the cursor on this range when navigating to this target.
+    pub focus_range: Option<TextRange>,
+    pub name: SmolStr,
+    pub kind: SyntaxKind,
+    pub container_name: Option<SmolStr>,
+    pub description: Option<String>,
+    pub docs: Option<String>,
 }
 pub(crate) trait ToNav {
@@ -42,44 +55,9 @@ pub(crate) trait TryToNav {
 }
 impl NavigationTarget {
-    /// When `focus_range` is specified, returns it. otherwise
+    pub fn focus_or_full_range(&self) -> TextRange {
-    /// returns `full_range`
-    pub fn range(&self) -> TextRange {
        self.focus_range.unwrap_or(self.full_range)
    }
-    /// A "most interesting" range withing the `full_range`.
-    ///
-    /// Typically, `full_range` is the whole syntax node,
-    /// including doc comments, and `focus_range` is the range of the identifier.
-    pub fn focus_range(&self) -> Option<TextRange> {
-        self.focus_range
-    }
-    pub fn full_range(&self) -> TextRange {
-        self.full_range
-    }
-    pub fn file_id(&self) -> FileId {
-        self.file_id
-    }
-    pub fn name(&self) -> &SmolStr {
-        &self.name
-    }
-    pub fn container_name(&self) -> Option<&SmolStr> {
-        self.container_name.as_ref()
-    }
-    pub fn kind(&self) -> SyntaxKind {
-        self.kind
-    }
-    pub fn docs(&self) -> Option<&str> {
-        self.docs.as_deref()
-    }
-    pub fn description(&self) -> Option<&str> {
-        self.description.as_deref()
-    }
    pub(crate) fn from_module_to_decl(db: &RootDatabase, module: hir::Module) -> NavigationTarget {
        let name = module.name(db).map(|it| it.to_string().into()).unwrap_or_default();
@@ -107,17 +85,12 @@ impl NavigationTarget {
    #[cfg(test)]
    pub(crate) fn debug_render(&self) -> String {
-        let mut buf = format!(
+        let mut buf =
-            "{} {:?} {:?} {:?}",
+            format!("{} {:?} {:?} {:?}", self.name, self.kind, self.file_id, self.full_range);
-            self.name(),
+        if let Some(focus_range) = self.focus_range {
-            self.kind(),
-            self.file_id(),
-            self.full_range()
-        );
-        if let Some(focus_range) = self.focus_range() {
            buf.push_str(&format!(" {:?}", focus_range))
        }
-        if let Some(container_name) = self.container_name() {
+        if let Some(container_name) = &self.container_name {
            buf.push_str(&format!(" {}", container_name))
        }
        buf
diff --git a/crates/ra_ide/src/display/short_label.rs b/crates/ra_ide/src/display/short_label.rs
index d37260e96..5588130a1 100644
--- a/crates/ra_ide/src/display/short_label.rs
+++ b/crates/ra_ide/src/display/short_label.rs
@@ -9,7 +9,7 @@ pub(crate) trait ShortLabel {
 impl ShortLabel for ast::FnDef {
    fn short_label(&self) -> Option<String> {
-        Some(crate::display::function_label(self))
+        Some(crate::display::function_declaration(self))
    }
 }
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/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index c30b20611..db6d20a37 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -130,7 +130,7 @@ mod tests {
        assert_eq!(navs.len(), 1);
        let nav = navs.pop().unwrap();
-        assert_eq!(expected, FileRange { file_id: nav.file_id(), range: nav.range() });
+        assert_eq!(expected, FileRange { file_id: nav.file_id, range: nav.focus_or_full_range() });
    }
    #[test]
diff --git a/crates/ra_ide/src/goto_implementation.rs b/crates/ra_ide/src/goto_implementation.rs
index 9acc960fc..3ee048f28 100644
--- a/crates/ra_ide/src/goto_implementation.rs
+++ b/crates/ra_ide/src/goto_implementation.rs
@@ -98,7 +98,7 @@ mod tests {
        let mut actual = navs
            .into_iter()
-            .map(|nav| FileRange { file_id: nav.file_id(), range: nav.range() })
+            .map(|nav| FileRange { file_id: nav.file_id, range: nav.focus_or_full_range() })
            .collect::<Vec<_>>();
        actual.sort_by_key(key);
diff --git a/crates/ra_ide/src/goto_type_definition.rs b/crates/ra_ide/src/goto_type_definition.rs
index 069cb283e..8f52feea6 100644
--- a/crates/ra_ide/src/goto_type_definition.rs
+++ b/crates/ra_ide/src/goto_type_definition.rs
@@ -67,7 +67,7 @@ mod tests {
        let mut navs = analysis.goto_type_definition(position).unwrap().unwrap().info;
        assert_eq!(navs.len(), 1);
        let nav = navs.pop().unwrap();
-        assert_eq!(expected, FileRange { file_id: nav.file_id(), range: nav.range() });
+        assert_eq!(expected, FileRange { file_id: nav.file_id, range: nav.focus_or_full_range() });
    }
    #[test]
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index a4c97e7f9..d067c339d 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -133,8 +133,8 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
 fn show_implementations_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> {
    fn to_action(nav_target: NavigationTarget) -> HoverAction {
        HoverAction::Implementaion(FilePosition {
-            file_id: nav_target.file_id(),
+            file_id: nav_target.file_id,
-            offset: nav_target.range().start(),
+            offset: nav_target.focus_or_full_range().start(),
        })
    }
@@ -1357,11 +1357,11 @@ fn foo_<|>test() {}
                                    1,
                                ),
                                full_range: 0..24,
-                                name: "foo_test",
-                                kind: FN_DEF,
                                focus_range: Some(
                                    11..19,
                                ),
+                                name: "foo_test",
+                                kind: FN_DEF,
                                container_name: None,
                                description: None,
                                docs: None,
@@ -1400,11 +1400,11 @@ mod tests<|> {
                                    1,
                                ),
                                full_range: 0..46,
-                                name: "tests",
-                                kind: MODULE,
                                focus_range: Some(
                                    4..9,
                                ),
+                                name: "tests",
+                                kind: MODULE,
                                container_name: None,
                                description: None,
                                docs: None,
@@ -1439,11 +1439,11 @@ fn main() { let s<|>t = S{ f1:0 }; }
                                        1,
                                    ),
                                    full_range: 0..19,
-                                    name: "S",
-                                    kind: STRUCT_DEF,
                                    focus_range: Some(
                                        7..8,
                                    ),
+                                    name: "S",
+                                    kind: STRUCT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "struct S",
@@ -1478,11 +1478,11 @@ fn main() { let s<|>t = S{ f1:Arg(0) }; }
                                        1,
                                    ),
                                    full_range: 17..37,
-                                    name: "S",
-                                    kind: STRUCT_DEF,
                                    focus_range: Some(
                                        24..25,
                                    ),
+                                    name: "S",
+                                    kind: STRUCT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "struct S",
@@ -1497,11 +1497,11 @@ fn main() { let s<|>t = S{ f1:Arg(0) }; }
                                        1,
                                    ),
                                    full_range: 0..16,
-                                    name: "Arg",
-                                    kind: STRUCT_DEF,
                                    focus_range: Some(
                                        7..10,
                                    ),
+                                    name: "Arg",
+                                    kind: STRUCT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "struct Arg",
@@ -1536,11 +1536,11 @@ fn main() { let s<|>t = S{ f1: S{ f1: Arg(0) } }; }
                                        1,
                                    ),
                                    full_range: 17..37,
-                                    name: "S",
-                                    kind: STRUCT_DEF,
                                    focus_range: Some(
                                        24..25,
                                    ),
+                                    name: "S",
+                                    kind: STRUCT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "struct S",
@@ -1555,11 +1555,11 @@ fn main() { let s<|>t = S{ f1: S{ f1: Arg(0) } }; }
                                        1,
                                    ),
                                    full_range: 0..16,
-                                    name: "Arg",
-                                    kind: STRUCT_DEF,
                                    focus_range: Some(
                                        7..10,
                                    ),
+                                    name: "Arg",
+                                    kind: STRUCT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "struct Arg",
@@ -1597,11 +1597,11 @@ fn main() { let s<|>t = (A(1), B(2), M::C(3) ); }
                                        1,
                                    ),
                                    full_range: 0..14,
-                                    name: "A",
-                                    kind: STRUCT_DEF,
                                    focus_range: Some(
                                        7..8,
                                    ),
+                                    name: "A",
+                                    kind: STRUCT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "struct A",
@@ -1616,11 +1616,11 @@ fn main() { let s<|>t = (A(1), B(2), M::C(3) ); }
                                        1,
                                    ),
                                    full_range: 15..29,
-                                    name: "B",
-                                    kind: STRUCT_DEF,
                                    focus_range: Some(
                                        22..23,
                                    ),
+                                    name: "B",
+                                    kind: STRUCT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "struct B",
@@ -1635,11 +1635,11 @@ fn main() { let s<|>t = (A(1), B(2), M::C(3) ); }
                                        1,
                                    ),
                                    full_range: 42..60,
-                                    name: "C",
-                                    kind: STRUCT_DEF,
                                    focus_range: Some(
                                        53..54,
                                    ),
+                                    name: "C",
+                                    kind: STRUCT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "pub struct C",
@@ -1674,11 +1674,11 @@ fn main() { let s<|>t = foo(); }
                                        1,
                                    ),
                                    full_range: 0..12,
-                                    name: "Foo",
-                                    kind: TRAIT_DEF,
                                    focus_range: Some(
                                        6..9,
                                    ),
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "trait Foo",
@@ -1714,11 +1714,11 @@ fn main() { let s<|>t = foo(); }
                                        1,
                                    ),
                                    full_range: 0..15,
-                                    name: "Foo",
-                                    kind: TRAIT_DEF,
                                    focus_range: Some(
                                        6..9,
                                    ),
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "trait Foo",
@@ -1733,11 +1733,11 @@ fn main() { let s<|>t = foo(); }
                                        1,
                                    ),
                                    full_range: 16..25,
-                                    name: "S",
-                                    kind: STRUCT_DEF,
                                    focus_range: Some(
                                        23..24,
                                    ),
+                                    name: "S",
+                                    kind: STRUCT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "struct S",
@@ -1773,11 +1773,11 @@ fn main() { let s<|>t = foo(); }
                                        1,
                                    ),
                                    full_range: 0..12,
-                                    name: "Foo",
-                                    kind: TRAIT_DEF,
                                    focus_range: Some(
                                        6..9,
                                    ),
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "trait Foo",
@@ -1792,11 +1792,11 @@ fn main() { let s<|>t = foo(); }
                                        1,
                                    ),
                                    full_range: 13..25,
-                                    name: "Bar",
-                                    kind: TRAIT_DEF,
                                    focus_range: Some(
                                        19..22,
                                    ),
+                                    name: "Bar",
+                                    kind: TRAIT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "trait Bar",
@@ -1835,11 +1835,11 @@ fn main() { let s<|>t = foo(); }
                                        1,
                                    ),
                                    full_range: 0..15,
-                                    name: "Foo",
-                                    kind: TRAIT_DEF,
                                    focus_range: Some(
                                        6..9,
                                    ),
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "trait Foo",
@@ -1854,11 +1854,11 @@ fn main() { let s<|>t = foo(); }
                                        1,
                                    ),
                                    full_range: 16..31,
-                                    name: "Bar",
-                                    kind: TRAIT_DEF,
                                    focus_range: Some(
                                        22..25,
                                    ),
+                                    name: "Bar",
+                                    kind: TRAIT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "trait Bar",
@@ -1873,11 +1873,11 @@ fn main() { let s<|>t = foo(); }
                                        1,
                                    ),
                                    full_range: 32..44,
-                                    name: "S1",
-                                    kind: STRUCT_DEF,
                                    focus_range: Some(
                                        39..41,
                                    ),
+                                    name: "S1",
+                                    kind: STRUCT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "struct S1",
@@ -1892,11 +1892,11 @@ fn main() { let s<|>t = foo(); }
                                        1,
                                    ),
                                    full_range: 45..57,
-                                    name: "S2",
-                                    kind: STRUCT_DEF,
                                    focus_range: Some(
                                        52..54,
                                    ),
+                                    name: "S2",
+                                    kind: STRUCT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "struct S2",
@@ -1929,11 +1929,11 @@ fn foo(ar<|>g: &impl Foo) {}
                                        1,
                                    ),
                                    full_range: 0..12,
-                                    name: "Foo",
-                                    kind: TRAIT_DEF,
                                    focus_range: Some(
                                        6..9,
                                    ),
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "trait Foo",
@@ -1969,11 +1969,11 @@ fn foo(ar<|>g: &impl Foo + Bar<S>) {}
                                        1,
                                    ),
                                    full_range: 0..12,
-                                    name: "Foo",
-                                    kind: TRAIT_DEF,
                                    focus_range: Some(
                                        6..9,
                                    ),
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "trait Foo",
@@ -1988,11 +1988,11 @@ fn foo(ar<|>g: &impl Foo + Bar<S>) {}
                                        1,
                                    ),
                                    full_range: 13..28,
-                                    name: "Bar",
-                                    kind: TRAIT_DEF,
                                    focus_range: Some(
                                        19..22,
                                    ),
+                                    name: "Bar",
+                                    kind: TRAIT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "trait Bar",
@@ -2007,11 +2007,11 @@ fn foo(ar<|>g: &impl Foo + Bar<S>) {}
                                        1,
                                    ),
                                    full_range: 29..39,
-                                    name: "S",
-                                    kind: STRUCT_DEF,
                                    focus_range: Some(
                                        36..37,
                                    ),
+                                    name: "S",
+                                    kind: STRUCT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "struct S",
@@ -2045,11 +2045,11 @@ fn foo(ar<|>g: &impl Foo<S>) {}
                                        1,
                                    ),
                                    full_range: 0..15,
-                                    name: "Foo",
-                                    kind: TRAIT_DEF,
                                    focus_range: Some(
                                        6..9,
                                    ),
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "trait Foo",
@@ -2064,11 +2064,11 @@ fn foo(ar<|>g: &impl Foo<S>) {}
                                        1,
                                    ),
                                    full_range: 16..27,
-                                    name: "S",
-                                    kind: STRUCT_DEF,
                                    focus_range: Some(
                                        23..24,
                                    ),
+                                    name: "S",
+                                    kind: STRUCT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "struct S",
@@ -2107,11 +2107,11 @@ fn main() { let s<|>t = foo(); }
                                        1,
                                    ),
                                    full_range: 42..55,
-                                    name: "B",
-                                    kind: STRUCT_DEF,
                                    focus_range: Some(
                                        49..50,
                                    ),
+                                    name: "B",
+                                    kind: STRUCT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "struct B",
@@ -2126,11 +2126,11 @@ fn main() { let s<|>t = foo(); }
                                        1,
                                    ),
                                    full_range: 0..12,
-                                    name: "Foo",
-                                    kind: TRAIT_DEF,
                                    focus_range: Some(
                                        6..9,
                                    ),
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "trait Foo",
@@ -2163,11 +2163,11 @@ fn foo(ar<|>g: &dyn Foo) {}
                                        1,
                                    ),
                                    full_range: 0..12,
-                                    name: "Foo",
-                                    kind: TRAIT_DEF,
                                    focus_range: Some(
                                        6..9,
                                    ),
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "trait Foo",
@@ -2201,11 +2201,11 @@ fn foo(ar<|>g: &dyn Foo<S>) {}
                                        1,
                                    ),
                                    full_range: 0..15,
-                                    name: "Foo",
-                                    kind: TRAIT_DEF,
                                    focus_range: Some(
                                        6..9,
                                    ),
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "trait Foo",
@@ -2220,11 +2220,11 @@ fn foo(ar<|>g: &dyn Foo<S>) {}
                                        1,
                                    ),
                                    full_range: 16..27,
-                                    name: "S",
-                                    kind: STRUCT_DEF,
                                    focus_range: Some(
                                        23..24,
                                    ),
+                                    name: "S",
+                                    kind: STRUCT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "struct S",
@@ -2261,11 +2261,11 @@ fn foo(a<|>rg: &impl ImplTrait<B<dyn DynTrait<B<S>>>>) {}
                                        1,
                                    ),
                                    full_range: 0..21,
-                                    name: "ImplTrait",
-                                    kind: TRAIT_DEF,
                                    focus_range: Some(
                                        6..15,
                                    ),
+                                    name: "ImplTrait",
+                                    kind: TRAIT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "trait ImplTrait",
@@ -2280,11 +2280,11 @@ fn foo(a<|>rg: &impl ImplTrait<B<dyn DynTrait<B<S>>>>) {}
                                        1,
                                    ),
                                    full_range: 43..57,
-                                    name: "B",
-                                    kind: STRUCT_DEF,
                                    focus_range: Some(
                                        50..51,
                                    ),
+                                    name: "B",
+                                    kind: STRUCT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "struct B",
@@ -2299,11 +2299,11 @@ fn foo(a<|>rg: &impl ImplTrait<B<dyn DynTrait<B<S>>>>) {}
                                        1,
                                    ),
                                    full_range: 22..42,
-                                    name: "DynTrait",
-                                    kind: TRAIT_DEF,
                                    focus_range: Some(
                                        28..36,
                                    ),
+                                    name: "DynTrait",
+                                    kind: TRAIT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "trait DynTrait",
@@ -2318,11 +2318,11 @@ fn foo(a<|>rg: &impl ImplTrait<B<dyn DynTrait<B<S>>>>) {}
                                        1,
                                    ),
                                    full_range: 58..69,
-                                    name: "S",
-                                    kind: STRUCT_DEF,
                                    focus_range: Some(
                                        65..66,
                                    ),
+                                    name: "S",
+                                    kind: STRUCT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "struct S",
@@ -2366,11 +2366,11 @@ fn main() { let s<|>t = test().get(); }
                                        1,
                                    ),
                                    full_range: 0..62,
-                                    name: "Foo",
-                                    kind: TRAIT_DEF,
                                    focus_range: Some(
                                        6..9,
                                    ),
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
                                    container_name: None,
                                    description: Some(
                                        "trait Foo",
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 3cbae8a45..43a5e29b5 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -1,14 +1,16 @@
-use hir::{Adt, HirDisplay, Semantics, Type};
+use hir::{Adt, Callable, HirDisplay, Semantics, Type};
 use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 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::FileId;
+use ast::NameOwner;
+use either::Either;
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct InlayHintsConfig {
    pub type_hints: bool,
@@ -150,23 +152,26 @@ fn get_param_name_hints(
        _ => return None,
    };
-    let fn_signature = get_fn_signature(sema, &expr)?;
+    let callable = get_callable(sema, &expr)?;
-    let n_params_to_skip =
+    let hints = callable
-        if fn_signature.has_self_param && matches!(&expr, ast::Expr::MethodCallExpr(_)) {
+        .params(sema.db)
-            1
+        .into_iter()
-        } else {
-            0
-        };
-    let hints = fn_signature
-        .parameter_names
-        .iter()
-        .skip(n_params_to_skip)
        .zip(args)
-        .filter(|(param, arg)| should_show_param_name_hint(sema, &fn_signature, param, &arg))
+        .filter_map(|((param, _ty), arg)| match param? {
+            Either::Left(self_param) => Some((self_param.to_string(), arg)),
+            Either::Right(pat) => {
+                let param_name = match pat {
+                    ast::Pat::BindPat(it) => it.name()?.to_string(),
+                    it => it.to_string(),
+                };
+                Some((param_name, arg))
+            }
+        })
+        .filter(|(param_name, arg)| should_show_param_name_hint(sema, &callable, &param_name, &arg))
        .map(|(param_name, arg)| InlayHint {
            range: arg.syntax().text_range(),
            kind: InlayKind::ParameterHint,
-            label: param_name.into(),
+            label: param_name.to_string().into(),
        });
    acc.extend(hints);
@@ -250,28 +255,28 @@ fn should_not_display_type_hint(db: &RootDatabase, bind_pat: &ast::BindPat, pat_
 fn should_show_param_name_hint(
    sema: &Semantics<RootDatabase>,
-    fn_signature: &FunctionSignature,
+    callable: &Callable,
    param_name: &str,
    argument: &ast::Expr,
 ) -> bool {
    let param_name = param_name.trim_start_matches('_');
+    let fn_name = match callable.kind() {
+        hir::CallableKind::Function(it) => Some(it.name(sema.db).to_string()),
+        hir::CallableKind::TupleStruct(_)
+        | hir::CallableKind::TupleEnumVariant(_)
+        | hir::CallableKind::Closure => None,
+    };
    if param_name.is_empty()
-        || Some(param_name) == fn_signature.name.as_ref().map(|s| s.trim_start_matches('_'))
+        || Some(param_name) == fn_name.as_ref().map(|s| s.trim_start_matches('_'))
        || is_argument_similar_to_param_name(sema, argument, param_name)
        || param_name.starts_with("ra_fixture")
    {
        return false;
    }
-    let parameters_len = if fn_signature.has_self_param {
-        fn_signature.parameters.len() - 1
-    } else {
-        fn_signature.parameters.len()
-    };
    // avoid displaying hints for common functions like map, filter, etc.
    // or other obvious words used in std
-    !(parameters_len == 1 && is_obvious_param(param_name))
+    !(callable.n_params() == 1 && is_obvious_param(param_name))
 }
 fn is_argument_similar_to_param_name(
@@ -318,27 +323,10 @@ fn is_obvious_param(param_name: &str) -> bool {
    param_name.len() == 1 || is_obvious_param_name
 }
-fn get_fn_signature(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<FunctionSignature> {
+fn get_callable(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<Callable> {
    match expr {
-        ast::Expr::CallExpr(expr) => {
+        ast::Expr::CallExpr(expr) => sema.type_of_expr(&expr.expr()?)?.as_callable(sema.db),
-            // FIXME: Type::as_callable is broken for closures
+        ast::Expr::MethodCallExpr(expr) => sema.resolve_method_call_as_callable(expr),
-            let callable_def = sema.type_of_expr(&expr.expr()?)?.as_callable()?;
-            match callable_def {
-                hir::CallableDefId::FunctionId(it) => {
-                    Some(FunctionSignature::from_hir(sema.db, it.into()))
-                }
-                hir::CallableDefId::StructId(it) => {
-                    FunctionSignature::from_struct(sema.db, it.into())
-                }
-                hir::CallableDefId::EnumVariantId(it) => {
-                    FunctionSignature::from_enum_variant(sema.db, it.into())
-                }
-            }
-        }
-        ast::Expr::MethodCallExpr(expr) => {
-            let fn_def = sema.resolve_method_call(&expr)?;
-            Some(FunctionSignature::from_hir(sema.db, fn_def))
-        }
        _ => None,
    }
 }
@@ -360,7 +348,7 @@ mod tests {
        let inlay_hints = analysis.inlay_hints(file_id, &config).unwrap();
        let actual =
            inlay_hints.into_iter().map(|it| (it.range, it.label.to_string())).collect::<Vec<_>>();
-        assert_eq!(expected, actual);
+        assert_eq!(expected, actual, "\nExpected:\n{:#?}\n\nActual:\n{:#?}", expected, actual);
    }
    fn check_expect(config: InlayHintsConfig, ra_fixture: &str, expect: Expect) {
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 5d1f64e19..353f430ff 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 inlay_hints;
-mod call_info;
+mod join_lines;
-mod syntax_highlighting;
+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.
@@ -542,8 +545,8 @@ mod tests {
        let s = symbols.pop().unwrap();
-        assert_eq!(s.name(), "FooInner");
+        assert_eq!(s.name, "FooInner");
-        assert!(s.container_name().is_none());
+        assert!(s.container_name.is_none());
    }
    #[test]
@@ -558,8 +561,8 @@ fn foo() {
        let s = symbols.pop().unwrap();
-        assert_eq!(s.name(), "FooInner");
+        assert_eq!(s.name, "FooInner");
-        assert_eq!(s.container_name(), Some(&SmolStr::new("foo")));
+        assert_eq!(s.container_name, Some(SmolStr::new("foo")));
        let code = r#"
 mod foo {
@@ -571,8 +574,8 @@ mod foo {
        let s = symbols.pop().unwrap();
-        assert_eq!(s.name(), "FooInner");
+        assert_eq!(s.name, "FooInner");
-        assert_eq!(s.container_name(), Some(&SmolStr::new("foo")));
+        assert_eq!(s.container_name, Some(SmolStr::new("foo")));
    }
    #[test]
@@ -585,8 +588,8 @@ struct Foo;
        let symbols = get_symbols_matching(code, "Foo");
-        let fn_match = symbols.iter().find(|s| s.name() == "foo").map(|s| s.kind());
+        let fn_match = symbols.iter().find(|s| s.name == "foo").map(|s| s.kind);
-        let struct_match = symbols.iter().find(|s| s.name() == "Foo").map(|s| s.kind());
+        let struct_match = symbols.iter().find(|s| s.name == "Foo").map(|s| s.kind);
        assert_eq!(fn_match, Some(FN_DEF));
        assert_eq!(struct_match, Some(STRUCT_DEF));
diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs
index c2b0d5efe..fe1c074d1 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -74,8 +74,8 @@ impl IntoIterator for ReferenceSearchResult {
        let mut v = Vec::with_capacity(self.len());
        v.push(Reference {
            file_range: FileRange {
-                file_id: self.declaration.nav.file_id(),
+                file_id: self.declaration.nav.file_id,
-                range: self.declaration.nav.range(),
+                range: self.declaration.nav.focus_or_full_range(),
            },
            kind: self.declaration.kind,
            access: self.declaration.access,
@@ -112,7 +112,7 @@ pub(crate) fn find_all_refs(
        .filter(|r| search_kind == ReferenceKind::Other || search_kind == r.kind)
        .collect();
-    let decl_range = def.try_to_nav(sema.db)?.range();
+    let decl_range = def.try_to_nav(sema.db)?.focus_or_full_range();
    let declaration = Declaration {
        nav: def.try_to_nav(sema.db)?,
diff --git a/crates/ra_ide/src/runnables.rs b/crates/ra_ide/src/runnables.rs
index ed15d6494..0994beec5 100644
--- a/crates/ra_ide/src/runnables.rs
+++ b/crates/ra_ide/src/runnables.rs
@@ -299,11 +299,11 @@ fn bench() {}
                                1,
                            ),
                            full_range: 1..13,
-                            name: "main",
-                            kind: FN_DEF,
                            focus_range: Some(
                                4..8,
                            ),
+                            name: "main",
+                            kind: FN_DEF,
                            container_name: None,
                            description: None,
                            docs: None,
@@ -317,11 +317,11 @@ fn bench() {}
                                1,
                            ),
                            full_range: 15..39,
-                            name: "test_foo",
-                            kind: FN_DEF,
                            focus_range: Some(
                                26..34,
                            ),
+                            name: "test_foo",
+                            kind: FN_DEF,
                            container_name: None,
                            description: None,
                            docs: None,
@@ -342,11 +342,11 @@ fn bench() {}
                                1,
                            ),
                            full_range: 41..75,
-                            name: "test_foo",
-                            kind: FN_DEF,
                            focus_range: Some(
                                62..70,
                            ),
+                            name: "test_foo",
+                            kind: FN_DEF,
                            container_name: None,
                            description: None,
                            docs: None,
@@ -367,11 +367,11 @@ fn bench() {}
                                1,
                            ),
                            full_range: 77..99,
-                            name: "bench",
-                            kind: FN_DEF,
                            focus_range: Some(
                                89..94,
                            ),
+                            name: "bench",
+                            kind: FN_DEF,
                            container_name: None,
                            description: None,
                            docs: None,
@@ -410,11 +410,11 @@ fn foo() {}
                                1,
                            ),
                            full_range: 1..13,
-                            name: "main",
-                            kind: FN_DEF,
                            focus_range: Some(
                                4..8,
                            ),
+                            name: "main",
+                            kind: FN_DEF,
                            container_name: None,
                            description: None,
                            docs: None,
@@ -428,9 +428,9 @@ fn foo() {}
                                1,
                            ),
                            full_range: 15..57,
+                            focus_range: None,
                            name: "foo",
                            kind: FN_DEF,
-                            focus_range: None,
                            container_name: None,
                            description: None,
                            docs: None,
@@ -472,11 +472,11 @@ impl Data {
                                1,
                            ),
                            full_range: 1..13,
-                            name: "main",
-                            kind: FN_DEF,
                            focus_range: Some(
                                4..8,
                            ),
+                            name: "main",
+                            kind: FN_DEF,
                            container_name: None,
                            description: None,
                            docs: None,
@@ -490,9 +490,9 @@ impl Data {
                                1,
                            ),
                            full_range: 44..98,
+                            focus_range: None,
                            name: "foo",
                            kind: FN_DEF,
-                            focus_range: None,
                            container_name: None,
                            description: None,
                            docs: None,
@@ -529,11 +529,11 @@ mod test_mod {
                                1,
                            ),
                            full_range: 1..51,
-                            name: "test_mod",
-                            kind: MODULE,
                            focus_range: Some(
                                5..13,
                            ),
+                            name: "test_mod",
+                            kind: MODULE,
                            container_name: None,
                            description: None,
                            docs: None,
@@ -549,11 +549,11 @@ mod test_mod {
                                1,
                            ),
                            full_range: 20..49,
-                            name: "test_foo1",
-                            kind: FN_DEF,
                            focus_range: Some(
                                35..44,
                            ),
+                            name: "test_foo1",
+                            kind: FN_DEF,
                            container_name: None,
                            description: None,
                            docs: None,
@@ -595,11 +595,11 @@ mod foo {
                                1,
                            ),
                            full_range: 15..77,
-                            name: "test_mod",
-                            kind: MODULE,
                            focus_range: Some(
                                19..27,
                            ),
+                            name: "test_mod",
+                            kind: MODULE,
                            container_name: None,
                            description: None,
                            docs: None,
@@ -615,11 +615,11 @@ mod foo {
                                1,
                            ),
                            full_range: 38..71,
-                            name: "test_foo1",
-                            kind: FN_DEF,
                            focus_range: Some(
                                57..66,
                            ),
+                            name: "test_foo1",
+                            kind: FN_DEF,
                            container_name: None,
                            description: None,
                            docs: None,
@@ -663,11 +663,11 @@ mod foo {
                                1,
                            ),
                            full_range: 33..107,
-                            name: "test_mod",
-                            kind: MODULE,
                            focus_range: Some(
                                37..45,
                            ),
+                            name: "test_mod",
+                            kind: MODULE,
                            container_name: None,
                            description: None,
                            docs: None,
@@ -683,11 +683,11 @@ mod foo {
                                1,
                            ),
                            full_range: 60..97,
-                            name: "test_foo1",
-                            kind: FN_DEF,
                            focus_range: Some(
                                83..92,
                            ),
+                            name: "test_foo1",
+                            kind: FN_DEF,
                            container_name: None,
                            description: None,
                            docs: None,
@@ -726,11 +726,11 @@ fn test_foo1() {}
                                1,
                            ),
                            full_range: 1..50,
-                            name: "test_foo1",
-                            kind: FN_DEF,
                            focus_range: Some(
                                36..45,
                            ),
+                            name: "test_foo1",
+                            kind: FN_DEF,
                            container_name: None,
                            description: None,
                            docs: None,
@@ -774,11 +774,11 @@ fn test_foo1() {}
                                1,
                            ),
                            full_range: 1..72,
-                            name: "test_foo1",
-                            kind: FN_DEF,
                            focus_range: Some(
                                58..67,
                            ),
+                            name: "test_foo1",
+                            kind: FN_DEF,
                            container_name: None,
                            description: None,
                            docs: None,
diff --git a/crates/ra_ide/src/typing.rs b/crates/ra_ide/src/typing.rs
index 83776d2b6..d3ce744b4 100644
--- a/crates/ra_ide/src/typing.rs
+++ b/crates/ra_ide/src/typing.rs
@@ -39,7 +39,6 @@ pub(crate) const TRIGGER_CHARS: &str = ".=>";
 // Some features trigger on typing certain characters:
 //
 // - typing `let =` tries to smartly add `;` if `=` is followed by an existing expression
-// - Enter inside comments automatically inserts `///`
 // - typing `.` in a chain method call auto-indents
 pub(crate) fn on_char_typed(
    db: &RootDatabase,
diff --git a/crates/ra_ide/src/typing/on_enter.rs b/crates/ra_ide/src/typing/on_enter.rs
index 2faaa8ff0..143b1ae41 100644
--- a/crates/ra_ide/src/typing/on_enter.rs
+++ b/crates/ra_ide/src/typing/on_enter.rs
@@ -7,10 +7,31 @@ use ra_syntax::{
    ast::{self, AstToken},
    AstNode, SmolStr, SourceFile,
    SyntaxKind::*,
-    SyntaxToken, TextSize, TokenAtOffset,
+    SyntaxToken, TextRange, TextSize, TokenAtOffset,
 };
 use ra_text_edit::TextEdit;
+use test_utils::mark;
+// Feature: On Enter
+//
+// rust-analyzer can override kbd:[Enter] key to make it smarter:
+//
+// - kbd:[Enter] inside triple-slash comments automatically inserts `///`
+// - kbd:[Enter] in the middle or after a trailing space in `//` inserts `//`
+//
+// This action needs to be assigned to shortcut explicitly.
+//
+// VS Code::
+//
+// Add the following to `keybindings.json`:
+// [source,json]
+// ----
+// {
+//   "key": "Enter",
+//   "command": "rust-analyzer.onEnter",
+//   "when": "editorTextFocus && !suggestWidgetVisible && editorLangId == rust"
+// }
+// ----
 pub(crate) fn on_enter(db: &RootDatabase, position: FilePosition) -> Option<TextEdit> {
    let parse = db.parse(position.file_id);
    let file = parse.tree();
@@ -30,15 +51,25 @@ pub(crate) fn on_enter(db: &RootDatabase, position: FilePosition) -> Option<Text
        return None;
    }
+    let mut remove_last_space = false;
    // Continuing single-line non-doc comments (like this one :) ) is annoying
-    if prefix == "//" && comment_range.end() == position.offset && !followed_by_comment(&comment) {
+    if prefix == "//" && comment_range.end() == position.offset {
-        return None;
+        if comment.text().ends_with(' ') {
+            mark::hit!(continues_end_of_line_comment_with_space);
+            remove_last_space = true;
+        } else if !followed_by_comment(&comment) {
+            return None;
+        }
    }
    let indent = node_indent(&file, comment.syntax())?;
    let inserted = format!("\n{}{} $0", indent, prefix);
-    let edit = TextEdit::insert(position.offset, inserted);
+    let delete = if remove_last_space {
+        TextRange::new(position.offset - TextSize::of(' '), position.offset)
+    } else {
+        TextRange::empty(position.offset)
+    };
+    let edit = TextEdit::replace(delete, inserted);
    Some(edit)
 }
@@ -75,10 +106,10 @@ fn node_indent(file: &SourceFile, token: &SyntaxToken) -> Option<SmolStr> {
 #[cfg(test)]
 mod tests {
-    use test_utils::assert_eq_text;
+    use stdx::trim_indent;
+    use test_utils::{assert_eq_text, mark};
    use crate::mock_analysis::analysis_and_position;
-    use stdx::trim_indent;
    fn apply_on_enter(before: &str) -> Option<String> {
        let (analysis, position) = analysis_and_position(&before);
@@ -192,7 +223,7 @@ fn main() {
    }
    #[test]
-    fn does_not_continue_end_of_code_comment() {
+    fn does_not_continue_end_of_line_comment() {
        do_check_noop(
            r"
 fn main() {
@@ -202,4 +233,24 @@ fn main() {
 ",
        );
    }
+    #[test]
+    fn continues_end_of_line_comment_with_space() {
+        mark::check!(continues_end_of_line_comment_with_space);
+        do_check(
+            r#"
+fn main() {
+    // Fix me <|>
+    let x = 1 + 1;
+}
+"#,
+            r#"
+fn main() {
+    // Fix me
+    // $0
+    let x = 1 + 1;
+}
+"#,
+        );
+    }
 }
diff --git a/crates/rust-analyzer/src/cli.rs b/crates/rust-analyzer/src/cli.rs
index 6863f100b..753001949 100644
--- a/crates/rust-analyzer/src/cli.rs
+++ b/crates/rust-analyzer/src/cli.rs
@@ -10,7 +10,7 @@ mod ssr;
 use std::io::Read;
 use anyhow::Result;
-use ra_ide::{file_structure, Analysis};
+use ra_ide::Analysis;
 use ra_prof::profile;
 use ra_syntax::{AstNode, SourceFile};
@@ -48,8 +48,10 @@ pub fn parse(no_dump: bool) -> Result<()> {
 }
 pub fn symbols() -> Result<()> {
-    let file = file()?;
+    let text = read_stdin()?;
-    for s in file_structure(&file) {
+    let (analysis, file_id) = Analysis::from_single_file(text);
+    let structure = analysis.file_structure(file_id).unwrap();
+    for s in structure {
        println!("{:?}", s);
    }
    Ok(())
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index ed5e52871..68b2a2abd 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -127,6 +127,7 @@ pub struct ClientCapsConfig {
    pub resolve_code_action: bool,
    pub hover_actions: bool,
    pub status_notification: bool,
+    pub signature_help_label_offsets: bool,
 }
 impl Config {
@@ -302,6 +303,15 @@ impl Config {
            {
                self.client_caps.code_action_literals = value;
            }
+            if let Some(value) = doc_caps
+                .signature_help
+                .as_ref()
+                .and_then(|it| it.signature_information.as_ref())
+                .and_then(|it| it.parameter_information.as_ref())
+                .and_then(|it| it.label_offset_support)
+            {
+                self.client_caps.signature_help_label_offsets = value;
+            }
            self.completion.allow_snippets(false);
            if let Some(completion) = &doc_caps.completion {
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 42f21289a..d880570d2 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -341,10 +341,10 @@ pub(crate) fn handle_workspace_symbol(
    fn exec_query(snap: &GlobalStateSnapshot, query: Query) -> Result<Vec<SymbolInformation>> {
        let mut res = Vec::new();
        for nav in snap.analysis.symbol_search(query)? {
-            let container_name = nav.container_name().map(|v| v.to_string());
+            let container_name = nav.container_name.as_ref().map(|v| v.to_string());
            let info = SymbolInformation {
-                name: nav.name().to_string(),
+                name: nav.name.to_string(),
-                kind: to_proto::symbol_kind(nav.kind()),
+                kind: to_proto::symbol_kind(nav.kind),
                location: to_proto::location_from_nav(snap, nav)?,
                container_name,
                deprecated: None,
@@ -434,7 +434,7 @@ pub(crate) fn handle_runnables(
    let mut res = Vec::new();
    for runnable in snap.analysis.runnables(file_id)? {
        if let Some(offset) = offset {
-            if !runnable.nav.full_range().contains_inclusive(offset) {
+            if !runnable.nav.full_range.contains_inclusive(offset) {
                continue;
            }
        }
@@ -553,21 +553,16 @@ pub(crate) fn handle_signature_help(
    let _p = profile("handle_signature_help");
    let position = from_proto::file_position(&snap, params.text_document_position_params)?;
    let call_info = match snap.analysis.call_info(position)? {
-        None => return Ok(None),
        Some(it) => it,
+        None => return Ok(None),
    };
    let concise = !snap.config.call_info_full;
-    let mut active_parameter = call_info.active_parameter.map(|it| it as i64);
+    let res = to_proto::signature_help(
-    if concise && call_info.signature.has_self_param {
+        call_info,
-        active_parameter = active_parameter.map(|it| it.saturating_sub(1));
+        concise,
-    }
+        snap.config.client_caps.signature_help_label_offsets,
-    let sig_info = to_proto::signature_information(call_info.signature, concise);
+    );
+    Ok(Some(res))
-    Ok(Some(lsp_types::SignatureHelp {
-        signatures: vec![sig_info],
-        active_signature: Some(0),
-        active_parameter,
-    }))
 }
 pub(crate) fn handle_hover(
@@ -880,7 +875,7 @@ pub(crate) fn handle_code_lens(
            }
            let action = runnable.action();
-            let range = to_proto::range(&line_index, runnable.nav.range());
+            let range = to_proto::range(&line_index, runnable.nav.focus_or_full_range());
            let r = to_proto::runnable(&snap, file_id, runnable)?;
            if snap.config.lens.run {
                let lens = CodeLens {
@@ -1069,7 +1064,7 @@ pub(crate) fn handle_call_hierarchy_prepare(
    let RangeInfo { range: _, info: navs } = nav_info;
    let res = navs
        .into_iter()
-        .filter(|it| it.kind() == SyntaxKind::FN_DEF)
+        .filter(|it| it.kind == SyntaxKind::FN_DEF)
        .map(|it| to_proto::call_hierarchy_item(&snap, it))
        .collect::<Result<Vec<_>>>()?;
@@ -1095,7 +1090,7 @@ pub(crate) fn handle_call_hierarchy_incoming(
    let mut res = vec![];
    for call_item in call_items.into_iter() {
-        let file_id = call_item.target.file_id();
+        let file_id = call_item.target.file_id;
        let line_index = snap.analysis.file_line_index(file_id)?;
        let item = to_proto::call_hierarchy_item(&snap, call_item.target)?;
        res.push(CallHierarchyIncomingCall {
@@ -1130,7 +1125,7 @@ pub(crate) fn handle_call_hierarchy_outgoing(
    let mut res = vec![];
    for call_item in call_items.into_iter() {
-        let file_id = call_item.target.file_id();
+        let file_id = call_item.target.file_id;
        let line_index = snap.analysis.file_line_index(file_id)?;
        let item = to_proto::call_hierarchy_item(&snap, call_item.target)?;
        res.push(CallHierarchyOutgoingCall {
@@ -1226,13 +1221,13 @@ fn goto_location_command(snap: &GlobalStateSnapshot, nav: &NavigationTarget) ->
        let link = to_proto::location_link(snap, None, nav.clone()).ok()?;
        to_value(link).ok()?
    } else {
-        let range = FileRange { file_id: nav.file_id(), range: nav.range() };
+        let range = FileRange { file_id: nav.file_id, range: nav.focus_or_full_range() };
        let location = to_proto::location(snap, range).ok()?;
        to_value(location).ok()?
    };
    Some(Command {
-        title: nav.name().to_string(),
+        title: nav.name.to_string(),
        command: "rust-analyzer.gotoLocation".into(),
        arguments: Some(vec![value]),
    })
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index e60537fcd..687432ddb 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -4,8 +4,8 @@ use std::path::{self, Path};
 use itertools::Itertools;
 use ra_db::{FileId, FileRange};
 use ra_ide::{
-    Assist, AssistKind, CompletionItem, CompletionItemKind, Documentation, FileSystemEdit, Fold,
+    Assist, AssistKind, CallInfo, CompletionItem, CompletionItemKind, Documentation,
-    FoldKind, FunctionSignature, Highlight, HighlightModifier, HighlightTag, HighlightedRange,
+    FileSystemEdit, Fold, FoldKind, Highlight, HighlightModifier, HighlightTag, HighlightedRange,
    Indel, InlayHint, InlayKind, InsertTextFormat, LineIndex, Markup, NavigationTarget,
    ReferenceAccess, ResolvedAssist, Runnable, Severity, SourceChange, SourceFileEdit, TextEdit,
 };
@@ -219,29 +219,72 @@ pub(crate) fn completion_item(
    res
 }
-pub(crate) fn signature_information(
+pub(crate) fn signature_help(
-    signature: FunctionSignature,
+    call_info: CallInfo,
    concise: bool,
-) -> lsp_types::SignatureInformation {
+    label_offsets: bool,
-    let (label, documentation, params) = if concise {
+) -> lsp_types::SignatureHelp {
-        let mut params = signature.parameters;
+    let (label, parameters) = match (concise, label_offsets) {
-        if signature.has_self_param {
+        (_, false) => {
-            params.remove(0);
+            let params = call_info
+                .parameter_labels()
+                .map(|label| lsp_types::ParameterInformation {
+                    label: lsp_types::ParameterLabel::Simple(label.to_string()),
+                    documentation: None,
+                })
+                .collect::<Vec<_>>();
+            let label =
+                if concise { call_info.parameter_labels().join(", ") } else { call_info.signature };
+            (label, params)
+        }
+        (false, true) => {
+            let params = call_info
+                .parameter_ranges()
+                .iter()
+                .map(|it| [u32::from(it.start()).into(), u32::from(it.end()).into()])
+                .map(|label_offsets| lsp_types::ParameterInformation {
+                    label: lsp_types::ParameterLabel::LabelOffsets(label_offsets),
+                    documentation: None,
+                })
+                .collect::<Vec<_>>();
+            (call_info.signature, params)
+        }
+        (true, true) => {
+            let mut params = Vec::new();
+            let mut label = String::new();
+            let mut first = true;
+            for param in call_info.parameter_labels() {
+                if !first {
+                    label.push_str(", ");
+                }
+                first = false;
+                let start = label.len() as u64;
+                label.push_str(param);
+                let end = label.len() as u64;
+                params.push(lsp_types::ParameterInformation {
+                    label: lsp_types::ParameterLabel::LabelOffsets([start, end]),
+                    documentation: None,
+                });
+            }
+            (label, params)
        }
-        (params.join(", "), None, params)
-    } else {
-        (signature.to_string(), signature.doc.map(documentation), signature.parameters)
    };
-    let parameters: Vec<lsp_types::ParameterInformation> = params
+    let documentation = call_info.doc.map(|doc| {
-        .into_iter()
+        lsp_types::Documentation::MarkupContent(lsp_types::MarkupContent {
-        .map(|param| lsp_types::ParameterInformation {
+            kind: lsp_types::MarkupKind::Markdown,
-            label: lsp_types::ParameterLabel::Simple(param),
+            value: doc,
-            documentation: None,
        })
-        .collect();
+    });
-    lsp_types::SignatureInformation { label, documentation, parameters: Some(parameters) }
+    let signature =
+        lsp_types::SignatureInformation { label, documentation, parameters: Some(parameters) };
+    lsp_types::SignatureHelp {
+        signatures: vec![signature],
+        active_signature: None,
+        active_parameter: call_info.active_parameter.map(|it| it as i64),
+    }
 }
 pub(crate) fn inlay_int(line_index: &LineIndex, inlay_hint: InlayHint) -> lsp_ext::InlayHint {
@@ -454,9 +497,9 @@ pub(crate) fn location_from_nav(
    snap: &GlobalStateSnapshot,
    nav: NavigationTarget,
 ) -> Result<lsp_types::Location> {
-    let url = url(snap, nav.file_id());
+    let url = url(snap, nav.file_id);
-    let line_index = snap.analysis.file_line_index(nav.file_id())?;
+    let line_index = snap.analysis.file_line_index(nav.file_id)?;
-    let range = range(&line_index, nav.full_range());
+    let range = range(&line_index, nav.full_range);
    let loc = lsp_types::Location::new(url, range);
    Ok(loc)
 }
@@ -488,12 +531,12 @@ fn location_info(
    snap: &GlobalStateSnapshot,
    target: NavigationTarget,
 ) -> Result<(lsp_types::Url, lsp_types::Range, lsp_types::Range)> {
-    let line_index = snap.analysis.file_line_index(target.file_id())?;
+    let line_index = snap.analysis.file_line_index(target.file_id)?;
-    let target_uri = url(snap, target.file_id());
+    let target_uri = url(snap, target.file_id);
-    let target_range = range(&line_index, target.full_range());
+    let target_range = range(&line_index, target.full_range);
    let target_selection_range =
-        target.focus_range().map(|it| range(&line_index, it)).unwrap_or(target_range);
+        target.focus_range.map(|it| range(&line_index, it)).unwrap_or(target_range);
    Ok((target_uri, target_range, target_selection_range))
 }
@@ -512,13 +555,7 @@ pub(crate) fn goto_definition_response(
        let locations = targets
            .into_iter()
            .map(|nav| {
-                location(
+                location(snap, FileRange { file_id: nav.file_id, range: nav.focus_or_full_range() })
-                    snap,
-                    FileRange {
-                        file_id: nav.file_id(),
-                        range: nav.focus_range().unwrap_or(nav.range()),
-                    },
-                )
            })
            .collect::<Result<Vec<_>>>()?;
        Ok(locations.into())
@@ -623,9 +660,9 @@ pub(crate) fn call_hierarchy_item(
    snap: &GlobalStateSnapshot,
    target: NavigationTarget,
 ) -> Result<lsp_types::CallHierarchyItem> {
-    let name = target.name().to_string();
+    let name = target.name.to_string();
-    let detail = target.description().map(|it| it.to_string());
+    let detail = target.description.clone();
-    let kind = symbol_kind(target.kind());
+    let kind = symbol_kind(target.kind);
    let (uri, range, selection_range) = location_info(snap, target)?;
    Ok(lsp_types::CallHierarchyItem { name, kind, tags: None, detail, uri, range, selection_range })
 }
diff --git a/docs/user/manual.adoc b/docs/user/manual.adoc
index 7fab7237b..978b463d5 100644
--- a/docs/user/manual.adoc
+++ b/docs/user/manual.adoc
@@ -373,3 +373,22 @@ Or it is possible to specify vars more granularly:
 ```
 You can use any valid RegExp as a mask. Also note that a full runnable name is something like *run bin_or_example_name*, *test some::mod::test_name* or *test-mod some::mod*, so it is possible to distinguish binaries, single tests, and test modules with this masks: `"^run"`, `"^test "` (the trailing space matters!), and `"^test-mod"` respectively.
+==== Compiler feedback from external commands
+Instead of relying on the built-in `cargo check`, you can configure Code to run a command in the background and use the `$rustc-watch` problem matcher to generate inline error markers from its output.
+To do this you need to create a new https://code.visualstudio.com/docs/editor/tasks[VS Code Task] and set `rust-analyzer.checkOnSave.enable: false` in preferences.
+For example, if you want to run https://crates.io/crates/cargo-watch[`cargo watch`] instead, you might add the following to `.vscode/tasks.json`:
+```json
+{
+    "label": "Watch",
+    "group": "build",
+    "type": "shell",
+    "command": "cargo watch",
+    "problemMatcher": "$rustc-watch",
+    "isBackground": true
+}
+```