From d42346fed61f706d68fe888631a41ea5f2752d7f Mon Sep 17 00:00:00 2001 From: Benjamin Coenen <5719034+bnjjj@users.noreply.github.com> Date: Sat, 11 Apr 2020 22:54:18 +0200 Subject: Improve autocompletion by looking on the type and name Signed-off-by: Benjamin Coenen <5719034+bnjjj@users.noreply.github.com> --- crates/ra_ide/src/display/function_signature.rs | 57 ++++++++++++++++--------- 1 file changed, 36 insertions(+), 21 deletions(-) (limited to 'crates/ra_ide/src/display') diff --git a/crates/ra_ide/src/display/function_signature.rs b/crates/ra_ide/src/display/function_signature.rs index b967a6816..e58a78271 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, /// Parameter names of the function pub parameter_names: Vec, + /// Parameter types of the function + pub parameter_types: Vec, /// Optional return type pub ret_type: Option, /// Where predicates @@ -62,14 +64,14 @@ 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)); + parameter_types.push(raw_param.split(':').nth(1).unwrap()[1..].to_string()); + params.push(raw_param); + } Some( FunctionSignature { @@ -79,6 +81,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 +102,14 @@ 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)); + parameter_types.push(raw_param.split(':').nth(1).unwrap()[1..].to_string()); + params.push(raw_param); + } Some( FunctionSignature { @@ -117,6 +119,7 @@ impl FunctionSignature { ret_type: None, parameters: params, parameter_names: vec![], + parameter_types, generic_parameters: vec![], where_predicates: vec![], doc: None, @@ -139,6 +142,7 @@ impl FunctionSignature { ret_type: None, parameters: params, parameter_names: vec![], + parameter_types: vec![], generic_parameters: vec![], where_predicates: vec![], doc: None, @@ -151,18 +155,28 @@ impl FunctionSignature { impl From<&'_ ast::FnDef> for FunctionSignature { fn from(node: &ast::FnDef) -> FunctionSignature { - fn param_list(node: &ast::FnDef) -> (bool, Vec) { + fn param_list(node: &ast::FnDef) -> (bool, Vec, Vec) { 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(); + + // TODO: 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 { @@ -192,7 +206,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 +218,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 -- cgit v1.2.3 From 1c3a1385a587f0713908c0ae888ffad31f13de11 Mon Sep 17 00:00:00 2001 From: Benjamin Coenen <5719034+bnjjj@users.noreply.github.com> Date: Tue, 21 Apr 2020 14:31:57 +0200 Subject: Improve autocompletion by looking on the type and name Signed-off-by: Benjamin Coenen <5719034+bnjjj@users.noreply.github.com> --- crates/ra_ide/src/display/function_signature.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'crates/ra_ide/src/display') diff --git a/crates/ra_ide/src/display/function_signature.rs b/crates/ra_ide/src/display/function_signature.rs index 2d175882b..b5e2785fe 100644 --- a/crates/ra_ide/src/display/function_signature.rs +++ b/crates/ra_ide/src/display/function_signature.rs @@ -73,7 +73,7 @@ impl FunctionSignature { 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 + // useful when you have tuple struct parameter_types.push(raw_param.clone()); } params.push(raw_param); @@ -177,7 +177,6 @@ impl From<&'_ ast::FnDef> for FunctionSignature { has_self_param = true; 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(), ); -- cgit v1.2.3