1 files changed, 172 insertions, 35 deletions

diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 977aafc51..1b631c7cd 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -1,18 +1,19 @@
 //! FIXME: write short doc here
 
-use hir::{HirDisplay, SourceAnalyzer};
+use hir::{HirDisplay, SourceAnalyzer, SourceBinder};
 use once_cell::unsync::Lazy;
 use ra_prof::profile;
 use ra_syntax::{
-    ast::{self, AstNode, TypeAscriptionOwner},
+    ast::{self, ArgListOwner, AstNode, TypeAscriptionOwner},
     match_ast, SmolStr, SourceFile, SyntaxKind, SyntaxNode, TextRange,
 };
 
-use crate::{db::RootDatabase, FileId};
+use crate::{db::RootDatabase, FileId, FunctionSignature};
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum InlayKind {
     TypeHint,
+    ParameterHint,
 }
 
 #[derive(Debug)]
@@ -28,22 +29,24 @@ pub(crate) fn inlay_hints(
     file: &SourceFile,
     max_inlay_hint_length: Option<usize>,
 ) -> Vec<InlayHint> {
-    file.syntax()
-        .descendants()
-        .flat_map(|node| get_inlay_hints(db, file_id, &node, max_inlay_hint_length))
-        .flatten()
-        .collect()
+    let mut sb = SourceBinder::new(db);
+    let mut res = Vec::new();
+    for node in file.syntax().descendants() {
+        get_inlay_hints(&mut res, &mut sb, file_id, &node, max_inlay_hint_length);
+    }
+    res
 }
 
 fn get_inlay_hints(
-    db: &RootDatabase,
+    acc: &mut Vec<InlayHint>,
+    sb: &mut SourceBinder<RootDatabase>,
     file_id: FileId,
     node: &SyntaxNode,
     max_inlay_hint_length: Option<usize>,
-) -> Option<Vec<InlayHint>> {
+) -> Option<()> {
     let _p = profile("get_inlay_hints");
-    let analyzer =
-        Lazy::new(|| SourceAnalyzer::new(db, hir::InFile::new(file_id.into(), node), None));
+    let db = sb.db;
+    let analyzer = Lazy::new(move || sb.analyze(hir::InFile::new(file_id.into(), node), None));
     match_ast! {
         match node {
             ast::LetStmt(it) => {
@@ -51,7 +54,7 @@ fn get_inlay_hints(
                     return None;
                 }
                 let pat = it.pat()?;
-                Some(get_pat_type_hints(db, &analyzer, pat, false, max_inlay_hint_length))
+                get_pat_type_hints(acc, db, &analyzer, pat, false, max_inlay_hint_length);
             },
             ast::LambdaExpr(it) => {
                 it.param_list().map(|param_list| {
@@ -59,49 +62,115 @@ fn get_inlay_hints(
                         .params()
                         .filter(|closure_param| closure_param.ascribed_type().is_none())
                         .filter_map(|closure_param| closure_param.pat())
-                        .map(|root_pat| get_pat_type_hints(db, &analyzer, root_pat, false, max_inlay_hint_length))
-                        .flatten()
-                        .collect()
-                })
+                        .for_each(|root_pat| get_pat_type_hints(acc, db, &analyzer, root_pat, false, max_inlay_hint_length))
+                });
             },
             ast::ForExpr(it) => {
                 let pat = it.pat()?;
-                Some(get_pat_type_hints(db, &analyzer, pat, false, max_inlay_hint_length))
+                get_pat_type_hints(acc, db, &analyzer, pat, false, max_inlay_hint_length);
             },
             ast::IfExpr(it) => {
                 let pat = it.condition()?.pat()?;
-                Some(get_pat_type_hints(db, &analyzer, pat, true, max_inlay_hint_length))
+                get_pat_type_hints(acc, db, &analyzer, pat, true, max_inlay_hint_length);
             },
             ast::WhileExpr(it) => {
                 let pat = it.condition()?.pat()?;
-                Some(get_pat_type_hints(db, &analyzer, pat, true, max_inlay_hint_length))
+                get_pat_type_hints(acc, db, &analyzer, pat, true, max_inlay_hint_length);
             },
             ast::MatchArmList(it) => {
-                Some(
-                    it
-                        .arms()
-                        .map(|match_arm| match_arm.pats())
-                        .flatten()
-                        .map(|root_pat| get_pat_type_hints(db, &analyzer, root_pat, true, max_inlay_hint_length))
-                        .flatten()
-                        .collect(),
-                )
-            },
-            _ => None,
+                it.arms()
+                    .map(|match_arm| match_arm.pats())
+                    .flatten()
+                    .for_each(|root_pat| get_pat_type_hints(acc, db, &analyzer, root_pat, true, max_inlay_hint_length));
+            },
+            ast::CallExpr(it) => {
+                get_param_name_hints(acc, db, &analyzer, ast::Expr::from(it));
+            },
+            ast::MethodCallExpr(it) => {
+                get_param_name_hints(acc, db, &analyzer, ast::Expr::from(it));
+            },
+            _ => (),
         }
+    };
+    Some(())
+}
+
+fn get_param_name_hints(
+    acc: &mut Vec<InlayHint>,
+    db: &RootDatabase,
+    analyzer: &SourceAnalyzer,
+    expr: ast::Expr,
+) -> Option<()> {
+    let args = match &expr {
+        ast::Expr::CallExpr(expr) => expr.arg_list()?.args(),
+        ast::Expr::MethodCallExpr(expr) => expr.arg_list()?.args(),
+        _ => return None,
+    };
+
+    let mut parameters = get_fn_signature(db, analyzer, &expr)?.parameter_names.into_iter();
+
+    if let ast::Expr::MethodCallExpr(_) = &expr {
+        parameters.next();
+    };
+
+    let hints = parameters
+        .zip(args)
+        .filter_map(|(param, arg)| {
+            if arg.syntax().kind() == SyntaxKind::LITERAL {
+                Some((arg.syntax().text_range(), param))
+            } else {
+                None
+            }
+        })
+        .map(|(range, param_name)| InlayHint {
+            range,
+            kind: InlayKind::ParameterHint,
+            label: param_name.into(),
+        });
+
+    acc.extend(hints);
+    Some(())
+}
+
+fn get_fn_signature(
+    db: &RootDatabase,
+    analyzer: &SourceAnalyzer,
+    expr: &ast::Expr,
+) -> Option<FunctionSignature> {
+    match expr {
+        ast::Expr::CallExpr(expr) => {
+            // FIXME: Type::as_callable is broken for closures
+            let callable_def = analyzer.type_of(db, &expr.expr()?)?.as_callable()?;
+            match callable_def {
+                hir::CallableDef::FunctionId(it) => {
+                    let fn_def = it.into();
+                    Some(FunctionSignature::from_hir(db, fn_def))
+                }
+                hir::CallableDef::StructId(it) => FunctionSignature::from_struct(db, it.into()),
+                hir::CallableDef::EnumVariantId(it) => {
+                    FunctionSignature::from_enum_variant(db, it.into())
+                }
+            }
+        }
+        ast::Expr::MethodCallExpr(expr) => {
+            let fn_def = analyzer.resolve_method_call(&expr)?;
+            Some(FunctionSignature::from_hir(db, fn_def))
+        }
+        _ => None,
     }
 }
 
 fn get_pat_type_hints(
+    acc: &mut Vec<InlayHint>,
     db: &RootDatabase,
     analyzer: &SourceAnalyzer,
     root_pat: ast::Pat,
     skip_root_pat_hint: bool,
     max_inlay_hint_length: Option<usize>,
-) -> Vec<InlayHint> {
+) {
     let original_pat = &root_pat.clone();
 
-    get_leaf_pats(root_pat)
+    let hints = get_leaf_pats(root_pat)
         .into_iter()
         .filter(|pat| !skip_root_pat_hint || pat != original_pat)
         .filter_map(|pat| {
@@ -115,8 +184,9 @@ fn get_pat_type_hints(
             range,
             kind: InlayKind::TypeHint,
             label: pat_type.display_truncated(db, max_inlay_hint_length).to_string().into(),
-        })
-        .collect()
+        });
+
+    acc.extend(hints);
 }
 
 fn get_leaf_pats(root_pat: ast::Pat) -> Vec<ast::Pat> {
@@ -605,4 +675,71 @@ fn main() {
         "###
         );
     }
+
+    #[test]
+    fn function_call_parameter_hint() {
+        let (analysis, file_id) = single_file(
+            r#"
+struct Test {}
+
+impl Test {
+    fn method(&self, param: i32) -> i32 {
+        param * 2
+    }
+}
+
+fn test_func(foo: i32, bar: i32, msg: &str, _: i32, last: i32) -> i32 {
+    foo + bar
+}
+
+fn main() {
+    let not_literal = 1;
+    let _: i32 = test_func(1, 2, "hello", 3, not_literal);
+    let t: Test = Test {};
+    t.method(123);
+    Test::method(&t, 3456);
+}"#,
+        );
+
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, None).unwrap(), @r###"
+        [
+            InlayHint {
+                range: [207; 218),
+                kind: TypeHint,
+                label: "i32",
+            },
+            InlayHint {
+                range: [251; 252),
+                kind: ParameterHint,
+                label: "foo",
+            },
+            InlayHint {
+                range: [254; 255),
+                kind: ParameterHint,
+                label: "bar",
+            },
+            InlayHint {
+                range: [257; 264),
+                kind: ParameterHint,
+                label: "msg",
+            },
+            InlayHint {
+                range: [266; 267),
+                kind: ParameterHint,
+                label: "_",
+            },
+            InlayHint {
+                range: [323; 326),
+                kind: ParameterHint,
+                label: "param",
+            },
+            InlayHint {
+                range: [350; 354),
+                kind: ParameterHint,
+                label: "param",
+            },
+        ]
+        "###
+        );
+    }
 }