Completing enum variants fills with parentheses

[ntBre]

Currently, enum variants get completed with parentheses inside the variant. This completion also leaves the cursor after the closing parentheses, forcing me to move back into the parentheses, delete everything inside, and then type what I actually want in there.

I would much rather the completion stop at Enum::Variant, allowing me to type the parentheses and their contents, or at most, for the completion snippet to leave me inside the parentheses. Could some kind of configuration option be added for this? If someone could point me in the right direction, I would be glad to try to work on this myself too.

I initially posted this as an Emacs lsp-mode issue but was pointed over here.

[flodiebold]

IMO if snippets aren't enabled we shouldn't be adding any parentheses at all, as we do for function calls; if snippets are enabled, we should still have a setting like for function calls to control whether to add snippets, parentheses or nothing. Or maybe we should just respect the callable snippet setting.

For functions this happens here:

rust-analyzer/crates/ide-completion/src/render/function.rs

Line 153 in 4596847

pub(super) fn add_call_parens<'b>(

note that this function already only gets called if snippets are enabled.
The code that would need to be changed is here:

rust-analyzer/crates/ide-completion/src/render/variant.rs

Lines 45 to 65 in 4596847

	pub(crate) fn render_tuple_lit(
	db: &dyn HirDatabase,
	snippet_cap: Option<SnippetCap>,
	fields: &[hir::Field],
	path: &str,
	) -> RenderedLiteral {
	let completions = fields.iter().enumerate().format_with(", ", |(idx, _), f| {
	if snippet_cap.is_some() {
	f(&format_args!("${{{}:()}}", idx + 1))
	} else {
	f(&format_args!("()"))
	}
	});
	let types = fields.iter().format_with(", ", |field, f| f(&field.ty(db).display(db)));
	RenderedLiteral {
	literal: format!("{}({})", path, completions),
	detail: format!("{}({})", path, types),
	}
	}

[ntBre]

IMO if snippets aren't enabled we shouldn't be adding any parentheses at all, as we do for function calls; if snippets are enabled, we should still have a setting like for function calls to control whether to add snippets, parentheses or nothing. Or maybe we should just respect the callable snippet setting.

I definitely agree. I have lsp-rust-analyzer-completion-add-call-parenthesis set to nil, and I think I have snippets enabled otherwise, so it would be great to have a similar setting for this.

Thank you very much for the code pointers! I'll try to dive in later today.

[ntBre]

Sorry for the delay on this, I finally got some time to look into it. I added a commit that handles the very basic version of what I wanted, but it certainly doesn't cover everything we've talked about. I also couldn't figure out how to update the label on the completion, so it still says "Variant(...)" even though it only completes "Variant" as I wanted.

I guess I will need to make the signature of render_tuple_lit more like that of add_call_parens and pass more information around. Does that sound right to you? Thanks again for all of the pointers!

[ntBre]

I looked more closely and added another commit taking care of the label. I'm now happy with the changes for my use case at least. I think now the only part missing is handling the case with snippets enabled.