8 files changed, 274 insertions, 30 deletions

diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index 4a1a2a04a..3be8b1903 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -94,5 +94,8 @@ pub(crate) fn completions(
     complete_macro_in_item_position::complete_macro_in_item_position(&mut acc, &ctx);
     complete_trait_impl::complete_trait_impl(&mut acc, &ctx);
 
+    // Reorder completion items if there is a sort_option
+    acc.sort();
+
     Some(acc)
 }
diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs
index f433faef3..cb899d8ff 100644
--- a/crates/ra_ide/src/completion/complete_dot.rs
+++ b/crates/ra_ide/src/completion/complete_dot.rs
@@ -1,13 +1,23 @@
 //! FIXME: write short doc here
 
-use hir::{HasVisibility, Type};
+use hir::{
+    HasVisibility,
+    // HirDisplay,
+    Type,
+};
 
 use crate::completion::completion_item::CompletionKind;
 use crate::{
-    completion::{completion_context::CompletionContext, completion_item::Completions},
+    call_info::call_info,
+    completion::{
+        completion_context::CompletionContext,
+        completion_item::{Completions, SortOption},
+    },
+    // CallInfo,
     CompletionItem,
 };
 use rustc_hash::FxHashSet;
+// use std::cmp::Ordering;
 
 /// Complete dot accesses, i.e. fields or methods (and .await syntax).
 pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
@@ -37,7 +47,41 @@ pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
 
 fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
     for receiver in receiver.autoderef(ctx.db) {
-        for (field, ty) in receiver.fields(ctx.db) {
+        let fields = receiver.fields(ctx.db);
+
+        // If we use this implementation we can delete call_info in the CompletionContext
+        if let Some(call_info) = call_info(ctx.db, ctx.file_position) {
+            acc.with_sort_option(SortOption::CallFn(call_info));
+        }
+
+        // // For Call Fn
+        // if let Some(call_info) = &ctx.call_info {
+        //     if let Some(active_parameter_type) = call_info.active_parameter_type() {
+        //         let active_parameter_name = call_info.active_parameter_name().unwrap();
+        //         fields.sort_by(|a, b| {
+        //             // For the same type
+        //             if active_parameter_type == a.1.display(ctx.db).to_string() {
+        //                 // If same type + same name then go top position
+        //                 if active_parameter_name == a.0.name(ctx.db).to_string() {
+        //                     Ordering::Less
+        //                 } else {
+        //                     if active_parameter_type == b.1.display(ctx.db).to_string() {
+        //                         Ordering::Equal
+        //                     } else {
+        //                         Ordering::Less
+        //                     }
+        //                 }
+        //             } else {
+        //                 Ordering::Greater
+        //             }
+        //         });
+        //     }
+        // }
+
+        // For Lit struct fields
+        // ---
+
+        for (field, ty) in fields {
             if ctx.scope().module().map_or(false, |m| !field.is_visible_from(ctx.db, m)) {
                 // Skip private field. FIXME: If the definition location of the
                 // field is editable, we should show the completion
@@ -70,13 +114,20 @@ fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &T
 
 #[cfg(test)]
 mod tests {
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{
+        test_utils::{do_completion, do_completion_without_sort},
+        CompletionItem, CompletionKind,
+    };
     use insta::assert_debug_snapshot;
 
     fn do_ref_completion(code: &str) -> Vec<CompletionItem> {
         do_completion(code, CompletionKind::Reference)
     }
 
+    fn do_ref_completion_without_sort(code: &str) -> Vec<CompletionItem> {
+        do_completion_without_sort(code, CompletionKind::Reference)
+    }
+
     #[test]
     fn test_struct_field_completion() {
         assert_debug_snapshot!(
@@ -104,6 +155,92 @@ mod tests {
     }
 
     #[test]
+    fn test_struct_field_completion_in_func_call() {
+        assert_debug_snapshot!(
+        do_ref_completion_without_sort(
+                r"
+                struct A { another_field: i64, the_field: u32, my_string: String }
+                fn test(my_param: u32) -> u32 { my_param }
+                fn foo(a: A) {
+                    test(a.<|>)
+                }
+                ",
+        ),
+            @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: [201; 201),
+                delete: [201; 201),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+            },
+            CompletionItem {
+                label: "another_field",
+                source_range: [201; 201),
+                delete: [201; 201),
+                insert: "another_field",
+                kind: Field,
+                detail: "i64",
+            },
+            CompletionItem {
+                label: "my_string",
+                source_range: [201; 201),
+                delete: [201; 201),
+                insert: "my_string",
+                kind: Field,
+                detail: "{unknown}",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_struct_field_completion_in_func_call_with_type_and_name() {
+        assert_debug_snapshot!(
+        do_ref_completion_without_sort(
+                r"
+                struct A { another_field: i64, another_good_type: u32, the_field: u32 }
+                fn test(the_field: u32) -> u32 { the_field }
+                fn foo(a: A) {
+                    test(a.<|>)
+                }
+                ",
+        ),
+            @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: [208; 208),
+                delete: [208; 208),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+            },
+            CompletionItem {
+                label: "another_good_type",
+                source_range: [208; 208),
+                delete: [208; 208),
+                insert: "another_good_type",
+                kind: Field,
+                detail: "u32",
+            },
+            CompletionItem {
+                label: "another_field",
+                source_range: [208; 208),
+                delete: [208; 208),
+                insert: "another_field",
+                kind: Field,
+                detail: "i64",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
     fn test_struct_field_completion_self() {
         assert_debug_snapshot!(
         do_ref_completion(
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 8b3401595..da054f7a2 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -11,7 +11,7 @@ use ra_syntax::{
 };
 use ra_text_edit::AtomTextEdit;
 
-use crate::{completion::CompletionConfig, FilePosition};
+use crate::{call_info::call_info, completion::CompletionConfig, CallInfo, FilePosition};
 
 /// `CompletionContext` is created early during completion to figure out, where
 /// exactly is the cursor, syntax-wise.
@@ -21,6 +21,7 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) db: &'a RootDatabase,
     pub(super) config: &'a CompletionConfig,
     pub(super) offset: TextUnit,
+    pub(super) file_position: FilePosition,
     /// The token before the cursor, in the original file.
     pub(super) original_token: SyntaxToken,
     /// The token before the cursor, in the macro-expanded file.
@@ -32,6 +33,7 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) record_lit_syntax: Option<ast::RecordLit>,
     pub(super) record_pat_syntax: Option<ast::RecordPat>,
     pub(super) impl_def: Option<ast::ImplDef>,
+    pub(super) call_info: Option<CallInfo>,
     pub(super) is_param: bool,
     /// If a name-binding or reference to a const in a pattern.
     /// Irrefutable patterns (like let) are excluded.
@@ -88,9 +90,11 @@ impl<'a> CompletionContext<'a> {
             original_token,
             token,
             offset: position.offset,
+            file_position: position,
             krate,
             name_ref_syntax: None,
             function_syntax: None,
+            call_info: None,
             use_item_syntax: None,
             record_lit_syntax: None,
             record_pat_syntax: None,
@@ -262,6 +266,8 @@ impl<'a> CompletionContext<'a> {
         self.use_item_syntax =
             self.sema.ancestors_with_macros(self.token.parent()).find_map(ast::UseItem::cast);
 
+        self.call_info = call_info(self.db, self.file_position);
+
         self.function_syntax = self
             .sema
             .ancestors_with_macros(self.token.parent())
diff --git a/crates/ra_ide/src/completion/completion_item.rs b/crates/ra_ide/src/completion/completion_item.rs
index bc0f1aff5..f8e6e53f1 100644
--- a/crates/ra_ide/src/completion/completion_item.rs
+++ b/crates/ra_ide/src/completion/completion_item.rs
@@ -1,7 +1,8 @@
 //! FIXME: write short doc here
 
-use std::fmt;
+use std::{cmp::Ordering, fmt};
 
+use crate::CallInfo;
 use hir::Documentation;
 use ra_syntax::TextRange;
 use ra_text_edit::TextEdit;
@@ -297,10 +298,17 @@ impl<'a> Into<CompletionItem> for Builder {
     }
 }
 
+#[derive(Debug)]
+pub(crate) enum SortOption {
+    CallFn(CallInfo),
+    // LitStruct,
+}
+
 /// Represents an in-progress set of completions being built.
 #[derive(Debug, Default)]
 pub(crate) struct Completions {
     buf: Vec<CompletionItem>,
+    sort_option: Option<SortOption>,
 }
 
 impl Completions {
@@ -314,6 +322,46 @@ impl Completions {
     {
         items.into_iter().for_each(|item| self.add(item.into()))
     }
+
+    pub(crate) fn with_sort_option(&mut self, sort_option: SortOption) {
+        self.sort_option = Some(sort_option);
+    }
+
+    pub(crate) fn sort(&mut self) {
+        if self.sort_option.is_none() {
+            return;
+        }
+        let sort_option = self.sort_option.as_ref().unwrap();
+
+        match sort_option {
+            SortOption::CallFn(call_info) => {
+                if let Some(active_parameter_type) = call_info.active_parameter_type() {
+                    let active_parameter_name = call_info.active_parameter_name().unwrap();
+
+                    self.buf.sort_by(|a, b| {
+                        // For the same type
+                        if let Some(a_parameter_type) = &a.detail {
+                            if &active_parameter_type == a_parameter_type {
+                                // If same type + same name then go top position
+                                if active_parameter_name != a.label {
+                                    if let Some(b_parameter_type) = &b.detail {
+                                        if &active_parameter_type == b_parameter_type {
+                                            return Ordering::Equal;
+                                        }
+                                    }
+                                }
+                                Ordering::Less
+                            } else {
+                                Ordering::Greater
+                            }
+                        } else {
+                            Ordering::Greater
+                        }
+                    });
+                }
+            } // _ => unimplemented!("sort options not already implemented"),
+        }
+    }
 }
 
 impl Into<Vec<CompletionItem>> for Completions {
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index 55f75b15a..8be2d02d0 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -367,7 +367,7 @@ mod tests {
         ra_fixture: &str,
         options: CompletionConfig,
     ) -> Vec<CompletionItem> {
-        do_completion_with_options(ra_fixture, CompletionKind::Reference, &options)
+        do_completion_with_options(ra_fixture, CompletionKind::Reference, &options, true)
     }
 
     #[test]
diff --git a/crates/ra_ide/src/completion/test_utils.rs b/crates/ra_ide/src/completion/test_utils.rs
index eb90b5279..f54d15a90 100644
--- a/crates/ra_ide/src/completion/test_utils.rs
+++ b/crates/ra_ide/src/completion/test_utils.rs
@@ -7,13 +7,18 @@ use crate::{
 };
 
 pub(crate) fn do_completion(code: &str, kind: CompletionKind) -> Vec<CompletionItem> {
-    do_completion_with_options(code, kind, &CompletionConfig::default())
+    do_completion_with_options(code, kind, &CompletionConfig::default(), true)
+}
+
+pub(crate) fn do_completion_without_sort(code: &str, kind: CompletionKind) -> Vec<CompletionItem> {
+    do_completion_with_options(code, kind, &CompletionConfig::default(), false)
 }
 
 pub(crate) fn do_completion_with_options(
     code: &str,
     kind: CompletionKind,
     options: &CompletionConfig,
+    sort_by_key: bool,
 ) -> Vec<CompletionItem> {
     let (analysis, position) = if code.contains("//-") {
         analysis_and_position(code)
@@ -24,6 +29,8 @@ pub(crate) fn do_completion_with_options(
     let completion_items: Vec<CompletionItem> = completions.into();
     let mut kind_completions: Vec<CompletionItem> =
         completion_items.into_iter().filter(|c| c.completion_kind == kind).collect();
-    kind_completions.sort_by_key(|c| c.label().to_owned());
+    if sort_by_key {
+        kind_completions.sort_by_key(|c| c.label().to_owned());
+    }
     kind_completions
 }
diff --git a/crates/ra_ide/src/display/function_signature.rs b/crates/ra_ide/src/display/function_signature.rs
index b967a6816..2d175882b 100644
--- a/crates/ra_ide/src/display/function_signature.rs
+++ b/crates/ra_ide/src/display/function_signature.rs
@@ -36,6 +36,8 @@ pub struct FunctionSignature {
     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
@@ -62,14 +64,20 @@ impl FunctionSignature {
             return None;
         };
 
-        let params = st
-            .fields(db)
-            .into_iter()
-            .map(|field: hir::StructField| {
-                let ty = field.signature_ty(db);
-                format!("{}", ty.display(db))
-            })
-            .collect();
+        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) {
+                parameter_types.push(param_type[1..].to_string());
+            } else {
+                // The unwrap_or_else is useful when you have tuple struct
+                parameter_types.push(raw_param.clone());
+            }
+            params.push(raw_param);
+        }
 
         Some(
             FunctionSignature {
@@ -79,6 +87,7 @@ impl FunctionSignature {
                 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: None,
@@ -99,15 +108,21 @@ impl FunctionSignature {
 
         let name = format!("{}::{}", parent_name, variant.name(db));
 
-        let params = variant
-            .fields(db)
-            .into_iter()
-            .map(|field: hir::StructField| {
-                let name = field.name(db);
-                let ty = field.signature_ty(db);
-                format!("{}: {}", name, ty.display(db))
-            })
-            .collect();
+        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) {
+                parameter_types.push(param_type[1..].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 {
@@ -117,6 +132,7 @@ impl FunctionSignature {
                 ret_type: None,
                 parameters: params,
                 parameter_names: vec![],
+                parameter_types,
                 generic_parameters: vec![],
                 where_predicates: vec![],
                 doc: None,
@@ -139,6 +155,7 @@ impl FunctionSignature {
                 ret_type: None,
                 parameters: params,
                 parameter_names: vec![],
+                parameter_types: vec![],
                 generic_parameters: vec![],
                 where_predicates: vec![],
                 doc: None,
@@ -151,18 +168,28 @@ impl FunctionSignature {
 
 impl From<&'_ ast::FnDef> for FunctionSignature {
     fn from(node: &ast::FnDef) -> FunctionSignature {
-        fn param_list(node: &ast::FnDef) -> (bool, Vec<String>) {
+        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;
-                    res.push(self_param.syntax().text().to_string())
+                    let raw_param = self_param.syntax().text().to_string();
+
+                    // FIXME: better solution ?
+                    res_types.push(
+                        raw_param.split(':').nth(1).unwrap_or_else(|| " Self")[1..].to_string(),
+                    );
+                    res.push(raw_param);
                 }
 
                 res.extend(param_list.params().map(|param| param.syntax().text().to_string()));
+                res_types.extend(param_list.params().map(|param| {
+                    param.syntax().text().to_string().split(':').nth(1).unwrap()[1..].to_string()
+                }));
             }
-            (has_self_param, res)
+            (has_self_param, res, res_types)
         }
 
         fn param_name_list(node: &ast::FnDef) -> Vec<String> {
@@ -192,7 +219,7 @@ impl From<&'_ ast::FnDef> for FunctionSignature {
             res
         }
 
-        let (has_self_param, parameters) = param_list(node);
+        let (has_self_param, parameters, parameter_types) = param_list(node);
 
         FunctionSignature {
             kind: CallableKind::Function,
@@ -204,6 +231,7 @@ impl From<&'_ ast::FnDef> for FunctionSignature {
                 .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
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 5599f143f..357c01cdf 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -127,6 +127,21 @@ pub struct CallInfo {
     pub active_parameter: Option<usize>,
 }
 
+impl CallInfo {
+    pub fn active_parameter_type(&self) -> Option<String> {
+        if let Some(id) = self.active_parameter {
+            return self.signature.parameter_types.get(id).map(|param_ty| param_ty.clone());
+        }
+        None
+    }
+    pub fn active_parameter_name(&self) -> Option<String> {
+        if let Some(id) = self.active_parameter {
+            return self.signature.parameter_names.get(id).map(|param_ty| param_ty.clone());
+        }
+        None
+    }
+}
+
 /// `AnalysisHost` stores the current state of the world.
 #[derive(Debug)]
 pub struct AnalysisHost {