language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-09-28 21:05:02 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Omit name hints for method names similar to parameter names

Browse source
This commit is contained in:
Kirill Bulatov 2020-05-03 15:07:57 +03:00
parent baa35b02b2
commit 8eb820f460
1 changed files with 25 additions and 13 deletions
Download patch file Download diff file Expand all files Collapse all files

38
crates/ra_ide/src/inlay_hints.rs
View file

@ -144,7 +144,7 @@ fn get_param_name_hints(
.iter() .iter()
.skip(n_params_to_skip) .skip(n_params_to_skip)
.zip(args) .zip(args)
.filter(|(param, arg)| should_show_param_hint(&fn_signature, param, &arg)) .filter(|(param, arg)| should_show_param_name_hint(&fn_signature, param, &arg))
.map(|(param_name, arg)| InlayHint { .map(|(param_name, arg)| InlayHint {
range: arg.syntax().text_range(), range: arg.syntax().text_range(),
kind: InlayKind::ParameterHint, kind: InlayKind::ParameterHint,
@ -181,7 +181,7 @@ fn get_bind_pat_hints(
fn pat_is_enum_variant(db: &RootDatabase, bind_pat: &ast::BindPat, pat_ty: &Type) -> bool { fn pat_is_enum_variant(db: &RootDatabase, bind_pat: &ast::BindPat, pat_ty: &Type) -> bool {
if let Some(Adt::Enum(enum_data)) = pat_ty.as_adt() { if let Some(Adt::Enum(enum_data)) = pat_ty.as_adt() {
let pat_text = bind_pat.syntax().to_string(); let pat_text = bind_pat.to_string();
enum_data enum_data
.variants(db) .variants(db)
.into_iter() .into_iter()
@ -198,7 +198,7 @@ fn should_not_display_type_hint(db: &RootDatabase, bind_pat: &ast::BindPat, pat_
} }
if let Some(Adt::Struct(s)) = pat_ty.as_adt() { if let Some(Adt::Struct(s)) = pat_ty.as_adt() {
if s.fields(db).is_empty() && s.name(db).to_string() == bind_pat.syntax().to_string() { if s.fields(db).is_empty() && s.name(db).to_string() == bind_pat.to_string() {
return true; return true;
} }
} }
@ -230,13 +230,13 @@ fn should_not_display_type_hint(db: &RootDatabase, bind_pat: &ast::BindPat, pat_
false false
} }
fn should_show_param_hint( fn should_show_param_name_hint(
fn_signature: &FunctionSignature, fn_signature: &FunctionSignature,
param_name: &str, param_name: &str,
argument: &ast::Expr, argument: &ast::Expr,
) -> bool { ) -> bool {
if param_name.is_empty() if param_name.is_empty()
|| is_argument_similar_to_param(argument, param_name) || is_argument_similar_to_param_name(argument, param_name)
|| Some(param_name.trim_start_matches('_')) || Some(param_name.trim_start_matches('_'))
== fn_signature.name.as_ref().map(|s| s.trim_start_matches('_')) == fn_signature.name.as_ref().map(|s| s.trim_start_matches('_'))
{ {
@ -254,20 +254,25 @@ fn should_show_param_hint(
parameters_len != 1 || !is_obvious_param(param_name) parameters_len != 1 || !is_obvious_param(param_name)
} }
fn is_argument_similar_to_param(argument: &ast::Expr, param_name: &str) -> bool { fn is_argument_similar_to_param_name(argument: &ast::Expr, param_name: &str) -> bool {
let argument_string = remove_ref(argument.clone()).syntax().to_string(); let argument_string = if let Some(repr) = get_string_representation(argument) {
repr
} else {
return false;
};
let param_name = param_name.trim_start_matches('_'); let param_name = param_name.trim_start_matches('_');
let argument_string = argument_string.trim_start_matches('_'); let argument_string = argument_string.trim_start_matches('_');
argument_string.starts_with(&param_name) || argument_string.ends_with(&param_name) argument_string.starts_with(&param_name) || argument_string.ends_with(&param_name)
} }
fn remove_ref(expr: ast::Expr) -> ast::Expr { fn get_string_representation(expr: &ast::Expr) -> Option<String> {
if let ast::Expr::RefExpr(ref_expr) = &expr { match expr {
if let Some(inner) = ref_expr.expr() { ast::Expr::MethodCallExpr(method_call_expr) => {
return inner; Some(method_call_expr.name_ref()?.to_string())
} }
ast::Expr::RefExpr(ref_expr) => get_string_representation(&ref_expr.expr()?),
_ => Some(expr.to_string()),
} }
expr
} }
fn is_obvious_param(param_name: &str) -> bool { fn is_obvious_param(param_name: &str) -> bool {
@ -1073,6 +1078,12 @@ struct TestVarContainer {
test_var: i32, test_var: i32,
} }
impl TestVarContainer {
fn test_var(&self) -> i32 {
self.test_var
}
}
struct Test {} struct Test {}
impl Test { impl Test {
@ -1114,12 +1125,13 @@ fn main() {
let test_var: i32 = 55; let test_var: i32 = 55;
test_processed.no_hints_expected(22, test_var); test_processed.no_hints_expected(22, test_var);
test_processed.no_hints_expected(33, container.test_var); test_processed.no_hints_expected(33, container.test_var);
test_processed.no_hints_expected(44, container.test_var());
test_processed.frob(false); test_processed.frob(false);
twiddle(true); twiddle(true);
doo(true); doo(true);
let param_begin: Param = Param {}; let mut param_begin: Param = Param {};
different_order(&param_begin); different_order(&param_begin);
different_order(&mut param_begin); different_order(&mut param_begin);