1 files changed, 82 insertions, 92 deletions

diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 62d364bfa..f2e4f7ee5 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,19 +152,22 @@ fn get_param_name_hints(
         _ => return None,
     };
 
-    let fn_signature = get_fn_signature(sema, &expr)?;
-    let n_params_to_skip =
-        if fn_signature.has_self_param && matches!(&expr, ast::Expr::MethodCallExpr(_)) {
-            1
-        } else {
-            0
-        };
-    let hints = fn_signature
-        .parameter_names
-        .iter()
-        .skip(n_params_to_skip)
+    let callable = get_callable(sema, &expr)?;
+    let hints = callable
+        .params(sema.db)
+        .into_iter()
         .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,
@@ -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) => {
-            // FIXME: Type::as_callable is broken for closures
-            let callable_def = sema.type_of_expr(&expr.expr()?)?.as_callable()?;
-            match callable_def {
-                hir::CallableDef::FunctionId(it) => {
-                    Some(FunctionSignature::from_hir(sema.db, it.into()))
-                }
-                hir::CallableDef::StructId(it) => {
-                    FunctionSignature::from_struct(sema.db, it.into())
-                }
-                hir::CallableDef::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))
-        }
+        ast::Expr::CallExpr(expr) => sema.type_of_expr(&expr.expr()?)?.as_callable(sema.db),
+        ast::Expr::MethodCallExpr(expr) => sema.resolve_method_call_as_callable(expr),
         _ => None,
     }
 }
@@ -351,19 +339,19 @@ mod tests {
     use crate::{inlay_hints::InlayHintsConfig, mock_analysis::single_file};
 
     fn check(ra_fixture: &str) {
-        check_with_config(ra_fixture, InlayHintsConfig::default());
+        check_with_config(InlayHintsConfig::default(), ra_fixture);
     }
 
-    fn check_with_config(ra_fixture: &str, config: InlayHintsConfig) {
+    fn check_with_config(config: InlayHintsConfig, ra_fixture: &str) {
         let (analysis, file_id) = single_file(ra_fixture);
         let expected = extract_annotations(&*analysis.file_text(file_id).unwrap());
         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(ra_fixture: &str, config: InlayHintsConfig, expect: Expect) {
+    fn check_expect(config: InlayHintsConfig, ra_fixture: &str, expect: Expect) {
         let (analysis, file_id) = single_file(ra_fixture);
         let inlay_hints = analysis.inlay_hints(file_id, &config).unwrap();
         expect.assert_debug_eq(&inlay_hints)
@@ -372,6 +360,12 @@ mod tests {
     #[test]
     fn param_hints_only() {
         check_with_config(
+            InlayHintsConfig {
+                parameter_hints: true,
+                type_hints: false,
+                chaining_hints: false,
+                max_length: None,
+            },
             r#"
 fn foo(a: i32, b: i32) -> i32 { a + b }
 fn main() {
@@ -382,47 +376,41 @@ fn main() {
       //^ b
     );
 }"#,
-            InlayHintsConfig {
-                parameter_hints: true,
-                type_hints: false,
-                chaining_hints: false,
-                max_length: None,
-            },
         );
     }
 
     #[test]
     fn hints_disabled() {
         check_with_config(
-            r#"
-fn foo(a: i32, b: i32) -> i32 { a + b }
-fn main() {
-    let _x = foo(4, 4);
-}"#,
             InlayHintsConfig {
                 type_hints: false,
                 parameter_hints: false,
                 chaining_hints: false,
                 max_length: None,
             },
+            r#"
+fn foo(a: i32, b: i32) -> i32 { a + b }
+fn main() {
+    let _x = foo(4, 4);
+}"#,
         );
     }
 
     #[test]
     fn type_hints_only() {
         check_with_config(
-            r#"
-fn foo(a: i32, b: i32) -> i32 { a + b }
-fn main() {
-    let _x = foo(4, 4);
-      //^^ i32
-}"#,
             InlayHintsConfig {
                 type_hints: true,
                 parameter_hints: false,
                 chaining_hints: false,
                 max_length: None,
             },
+            r#"
+fn foo(a: i32, b: i32) -> i32 { a + b }
+fn main() {
+    let _x = foo(4, 4);
+      //^^ i32
+}"#,
         );
     }
 
@@ -437,6 +425,8 @@ fn main() {
       //^^ Test<i32>
     let zz_ref = &zz;
       //^^^^^^ &Test<i32>
+    let test = || zz;
+      //^^^^ || -> Test<i32>
 }"#,
         );
     }
@@ -590,6 +580,7 @@ fn main() {
     #[test]
     fn hint_truncation() {
         check_with_config(
+            InlayHintsConfig { max_length: Some(8), ..Default::default() },
             r#"
 struct Smol<T>(T);
 
@@ -603,7 +594,6 @@ fn main() {
     let c = Smol(Smol(0u32))
       //^ Smol<Smol<…>>
 }"#,
-            InlayHintsConfig { max_length: Some(8), ..Default::default() },
         );
     }
 
@@ -673,6 +663,7 @@ fn main() {
     #[test]
     fn omitted_parameters_hints_heuristics() {
         check_with_config(
+            InlayHintsConfig { max_length: Some(8), ..Default::default() },
             r#"
 fn map(f: i32) {}
 fn filter(predicate: i32) {}
@@ -753,13 +744,13 @@ fn main() {
     let _: f64 = a.div_euclid(b);
     let _: f64 = a.abs_sub(b);
 }"#,
-            InlayHintsConfig { max_length: Some(8), ..Default::default() },
         );
     }
 
     #[test]
     fn unit_structs_have_no_type_hints() {
         check_with_config(
+            InlayHintsConfig { max_length: Some(8), ..Default::default() },
             r#"
 enum Result<T, E> { Ok(T), Err(E) }
 use Result::*;
@@ -772,13 +763,18 @@ fn main() {
         Err(SyntheticSyntax) => (),
     }
 }"#,
-            InlayHintsConfig { max_length: Some(8), ..Default::default() },
         );
     }
 
     #[test]
     fn chaining_hints_ignore_comments() {
         check_expect(
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
             r#"
 struct A(B);
 impl A { fn into_b(self) -> B { self.0 } }
@@ -792,12 +788,6 @@ fn main() {
         .into_c();
 }
 "#,
-            InlayHintsConfig {
-                parameter_hints: false,
-                type_hints: false,
-                chaining_hints: true,
-                max_length: None,
-            },
             expect![[r#"
                 [
                     InlayHint {
@@ -818,6 +808,12 @@ fn main() {
     #[test]
     fn chaining_hints_without_newlines() {
         check_with_config(
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
             r#"
 struct A(B);
 impl A { fn into_b(self) -> B { self.0 } }
@@ -828,18 +824,18 @@ struct C;
 fn main() {
     let c = A(B(C)).into_b().into_c();
 }"#,
-            InlayHintsConfig {
-                parameter_hints: false,
-                type_hints: false,
-                chaining_hints: true,
-                max_length: None,
-            },
         );
     }
 
     #[test]
     fn struct_access_chaining_hints() {
         check_expect(
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
             r#"
 struct A { pub b: B }
 struct B { pub c: C }
@@ -858,12 +854,6 @@ fn main() {
     let x = D
         .foo();
 }"#,
-            InlayHintsConfig {
-                parameter_hints: false,
-                type_hints: false,
-                chaining_hints: true,
-                max_length: None,
-            },
             expect![[r#"
                 [
                     InlayHint {
@@ -884,6 +874,12 @@ fn main() {
     #[test]
     fn generic_chaining_hints() {
         check_expect(
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
             r#"
 struct A<T>(T);
 struct B<T>(T);
@@ -903,12 +899,6 @@ fn main() {
         .into_c();
 }
 "#,
-            InlayHintsConfig {
-                parameter_hints: false,
-                type_hints: false,
-                chaining_hints: true,
-                max_length: None,
-            },
             expect![[r#"
                 [
                     InlayHint {