From fc8a1cd8006b021541ff673ec7f37a0f4b7bef57 Mon Sep 17 00:00:00 2001 From: Igor Aleksanov Date: Sun, 1 Nov 2020 12:35:04 +0300 Subject: Introduce render module --- crates/completion/src/render/builder_ext.rs | 94 ++++++++++++++++++++++ crates/completion/src/render/enum_variant.rs | 95 ++++++++++++++++++++++ crates/completion/src/render/function.rs | 87 ++++++++++++++++++++ crates/completion/src/render/macro_.rs | 116 +++++++++++++++++++++++++++ 4 files changed, 392 insertions(+) create mode 100644 crates/completion/src/render/builder_ext.rs create mode 100644 crates/completion/src/render/enum_variant.rs create mode 100644 crates/completion/src/render/function.rs create mode 100644 crates/completion/src/render/macro_.rs (limited to 'crates/completion/src/render') diff --git a/crates/completion/src/render/builder_ext.rs b/crates/completion/src/render/builder_ext.rs new file mode 100644 index 000000000..37b0d0459 --- /dev/null +++ b/crates/completion/src/render/builder_ext.rs @@ -0,0 +1,94 @@ +//! Extensions for `Builder` structure required for item rendering. + +use itertools::Itertools; +use test_utils::mark; + +use crate::{item::Builder, CompletionContext}; + +pub(super) enum Params { + Named(Vec), + Anonymous(usize), +} + +impl Params { + pub(super) fn len(&self) -> usize { + match self { + Params::Named(xs) => xs.len(), + Params::Anonymous(len) => *len, + } + } + + pub(super) fn is_empty(&self) -> bool { + self.len() == 0 + } +} + +impl Builder { + pub(super) fn should_add_parems(&self, ctx: &CompletionContext) -> bool { + if !ctx.config.add_call_parenthesis { + return false; + } + if ctx.use_item_syntax.is_some() { + mark::hit!(no_parens_in_use_item); + return false; + } + if ctx.is_pattern_call { + mark::hit!(dont_duplicate_pattern_parens); + return false; + } + if ctx.is_call { + return false; + } + + // Don't add parentheses if the expected type is some function reference. + if let Some(ty) = &ctx.expected_type { + if ty.is_fn() { + mark::hit!(no_call_parens_if_fn_ptr_needed); + return false; + } + } + + // Nothing prevents us from adding parentheses + true + } + + pub(super) fn add_call_parens( + mut self, + ctx: &CompletionContext, + name: String, + params: Params, + ) -> Builder { + if !self.should_add_parems(ctx) { + return self; + } + + let cap = match ctx.config.snippet_cap { + Some(it) => it, + None => return self, + }; + // If not an import, add parenthesis automatically. + mark::hit!(inserts_parens_for_function_calls); + + let (snippet, label) = if params.is_empty() { + (format!("{}()$0", name), format!("{}()", name)) + } else { + self = self.trigger_call_info(); + let snippet = match (ctx.config.add_call_argument_snippets, params) { + (true, Params::Named(params)) => { + let function_params_snippet = + params.iter().enumerate().format_with(", ", |(index, param_name), f| { + f(&format_args!("${{{}:{}}}", index + 1, param_name)) + }); + format!("{}({})$0", name, function_params_snippet) + } + _ => { + mark::hit!(suppress_arg_snippets); + format!("{}($0)", name) + } + }; + + (snippet, format!("{}(…)", name)) + }; + self.lookup_by(name).label(label).insert_snippet(cap, snippet) + } +} diff --git a/crates/completion/src/render/enum_variant.rs b/crates/completion/src/render/enum_variant.rs new file mode 100644 index 000000000..26cfdfeea --- /dev/null +++ b/crates/completion/src/render/enum_variant.rs @@ -0,0 +1,95 @@ +use hir::{HasAttrs, HirDisplay, ModPath, StructKind}; +use itertools::Itertools; +use test_utils::mark; + +use crate::{ + item::{CompletionItem, CompletionItemKind, CompletionKind}, + render::{builder_ext::Params, RenderContext}, +}; + +#[derive(Debug)] +pub(crate) struct EnumVariantRender<'a> { + ctx: RenderContext<'a>, + name: String, + variant: hir::EnumVariant, + path: Option, + qualified_name: String, + short_qualified_name: String, + variant_kind: StructKind, +} + +impl<'a> EnumVariantRender<'a> { + pub(crate) fn new( + ctx: RenderContext<'a>, + local_name: Option, + variant: hir::EnumVariant, + path: Option, + ) -> EnumVariantRender<'a> { + let name = local_name.unwrap_or_else(|| variant.name(ctx.db()).to_string()); + let variant_kind = variant.kind(ctx.db()); + + let (qualified_name, short_qualified_name) = match &path { + Some(path) => { + let full = path.to_string(); + let short = + path.segments[path.segments.len().saturating_sub(2)..].iter().join("::"); + (full, short) + } + None => (name.to_string(), name.to_string()), + }; + + EnumVariantRender { + ctx, + name, + variant, + path, + qualified_name, + short_qualified_name, + variant_kind, + } + } + + pub(crate) fn render(self) -> CompletionItem { + let mut builder = CompletionItem::new( + CompletionKind::Reference, + self.ctx.source_range(), + self.qualified_name.clone(), + ) + .kind(CompletionItemKind::EnumVariant) + .set_documentation(self.variant.docs(self.ctx.db())) + .set_deprecated(self.ctx.is_deprecated(self.variant)) + .detail(self.detail()); + + if self.variant_kind == StructKind::Tuple { + mark::hit!(inserts_parens_for_tuple_enums); + let params = Params::Anonymous(self.variant.fields(self.ctx.db()).len()); + builder = + builder.add_call_parens(self.ctx.completion, self.short_qualified_name, params); + } else if self.path.is_some() { + builder = builder.lookup_by(self.short_qualified_name); + } + + builder.build() + } + + fn detail(&self) -> String { + let detail_types = self + .variant + .fields(self.ctx.db()) + .into_iter() + .map(|field| (field.name(self.ctx.db()), field.signature_ty(self.ctx.db()))); + + match self.variant_kind { + StructKind::Tuple | StructKind::Unit => format!( + "({})", + detail_types.map(|(_, t)| t.display(self.ctx.db()).to_string()).format(", ") + ), + StructKind::Record => format!( + "{{ {} }}", + detail_types + .map(|(n, t)| format!("{}: {}", n, t.display(self.ctx.db()).to_string())) + .format(", ") + ), + } + } +} diff --git a/crates/completion/src/render/function.rs b/crates/completion/src/render/function.rs new file mode 100644 index 000000000..16f15e22c --- /dev/null +++ b/crates/completion/src/render/function.rs @@ -0,0 +1,87 @@ +use hir::{Documentation, HasAttrs, HasSource, Type}; +use syntax::{ast::Fn, display::function_declaration}; + +use crate::{ + item::{CompletionItem, CompletionItemKind, CompletionKind}, + render::{builder_ext::Params, RenderContext}, +}; + +#[derive(Debug)] +pub(crate) struct FunctionRender<'a> { + ctx: RenderContext<'a>, + name: String, + fn_: hir::Function, + ast_node: Fn, +} + +impl<'a> FunctionRender<'a> { + pub(crate) fn new( + ctx: RenderContext<'a>, + local_name: Option, + fn_: hir::Function, + ) -> FunctionRender<'a> { + let name = local_name.unwrap_or_else(|| fn_.name(ctx.db()).to_string()); + let ast_node = fn_.source(ctx.db()).value; + + FunctionRender { ctx, name, fn_, ast_node } + } + + pub(crate) fn render(self) -> CompletionItem { + let params = self.params(); + CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), self.name.clone()) + .kind(self.kind()) + .set_documentation(self.docs()) + .set_deprecated(self.ctx.is_deprecated(self.fn_)) + .detail(self.detail()) + .add_call_parens(self.ctx.completion, self.name, params) + .build() + } + + fn detail(&self) -> String { + function_declaration(&self.ast_node) + } + + fn add_arg(&self, arg: &str, ty: &Type) -> String { + if let Some(derefed_ty) = ty.remove_ref() { + for (name, local) in self.ctx.completion.locals.iter() { + if name == arg && local.ty(self.ctx.db()) == derefed_ty { + return (if ty.is_mutable_reference() { "&mut " } else { "&" }).to_string() + + &arg.to_string(); + } + } + } + arg.to_string() + } + + fn params(&self) -> Params { + let params_ty = self.fn_.params(self.ctx.db()); + let params = self + .ast_node + .param_list() + .into_iter() + .flat_map(|it| it.params()) + .zip(params_ty) + .flat_map(|(it, param_ty)| { + if let Some(pat) = it.pat() { + let name = pat.to_string(); + let arg = name.trim_start_matches("mut ").trim_start_matches('_'); + return Some(self.add_arg(arg, param_ty.ty())); + } + None + }) + .collect(); + Params::Named(params) + } + + fn kind(&self) -> CompletionItemKind { + if self.fn_.self_param(self.ctx.db()).is_some() { + CompletionItemKind::Method + } else { + CompletionItemKind::Function + } + } + + fn docs(&self) -> Option { + self.fn_.docs(self.ctx.db()) + } +} diff --git a/crates/completion/src/render/macro_.rs b/crates/completion/src/render/macro_.rs new file mode 100644 index 000000000..bcf94f47e --- /dev/null +++ b/crates/completion/src/render/macro_.rs @@ -0,0 +1,116 @@ +use hir::{Documentation, HasAttrs, HasSource}; +use syntax::display::macro_label; +use test_utils::mark; + +use crate::{ + item::{CompletionItem, CompletionItemKind, CompletionKind}, + render::RenderContext, +}; + +#[derive(Debug)] +pub(crate) struct MacroRender<'a> { + ctx: RenderContext<'a>, + name: String, + macro_: hir::MacroDef, + docs: Option, + bra: &'static str, + ket: &'static str, +} + +impl<'a> MacroRender<'a> { + pub(crate) fn new( + ctx: RenderContext<'a>, + name: String, + macro_: hir::MacroDef, + ) -> MacroRender<'a> { + let docs = macro_.docs(ctx.db()); + let docs_str = docs.as_ref().map_or("", |s| s.as_str()); + let (bra, ket) = guess_macro_braces(&name, docs_str); + + MacroRender { ctx, name, macro_, docs, bra, ket } + } + + pub(crate) fn render(&self) -> Option { + // FIXME: Currently proc-macro do not have ast-node, + // such that it does not have source + if self.macro_.is_proc_macro() { + return None; + } + + let mut builder = + CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), &self.label()) + .kind(CompletionItemKind::Macro) + .set_documentation(self.docs.clone()) + .set_deprecated(self.ctx.is_deprecated(self.macro_)) + .detail(self.detail()); + + let needs_bang = self.needs_bang(); + builder = match self.ctx.snippet_cap() { + Some(cap) if needs_bang => { + let snippet = self.snippet(); + let lookup = self.lookup(); + builder.insert_snippet(cap, snippet).lookup_by(lookup) + } + None if needs_bang => builder.insert_text(self.banged_name()), + _ => { + mark::hit!(dont_insert_macro_call_parens_unncessary); + builder.insert_text(&self.name) + } + }; + + Some(builder.build()) + } + + fn needs_bang(&self) -> bool { + self.ctx.completion.use_item_syntax.is_none() && !self.ctx.completion.is_macro_call + } + + fn label(&self) -> String { + format!("{}!{}…{}", self.name, self.bra, self.ket) + } + + fn snippet(&self) -> String { + format!("{}!{}$0{}", self.name, self.bra, self.ket) + } + + fn lookup(&self) -> String { + self.banged_name() + } + + fn banged_name(&self) -> String { + format!("{}!", self.name) + } + + fn detail(&self) -> String { + let ast_node = self.macro_.source(self.ctx.db()).value; + macro_label(&ast_node) + } +} + +fn guess_macro_braces(macro_name: &str, docs: &str) -> (&'static str, &'static str) { + let mut votes = [0, 0, 0]; + for (idx, s) in docs.match_indices(¯o_name) { + let (before, after) = (&docs[..idx], &docs[idx + s.len()..]); + // Ensure to match the full word + if after.starts_with('!') + && !before.ends_with(|c: char| c == '_' || c.is_ascii_alphanumeric()) + { + // It may have spaces before the braces like `foo! {}` + match after[1..].chars().find(|&c| !c.is_whitespace()) { + Some('{') => votes[0] += 1, + Some('[') => votes[1] += 1, + Some('(') => votes[2] += 1, + _ => {} + } + } + } + + // Insert a space before `{}`. + // We prefer the last one when some votes equal. + let (_vote, (bra, ket)) = votes + .iter() + .zip(&[(" {", "}"), ("[", "]"), ("(", ")")]) + .max_by_key(|&(&vote, _)| vote) + .unwrap(); + (*bra, *ket) +} -- cgit v1.2.3 From 944ccf60758305a1b15224defe622cfca6939aaa Mon Sep 17 00:00:00 2001 From: Igor Aleksanov Date: Sun, 1 Nov 2020 12:59:43 +0300 Subject: Add ConstRender --- crates/completion/src/render/const_.rs | 47 ++++++++++++++++++++++++++++++++ crates/completion/src/render/function.rs | 12 +++----- crates/completion/src/render/macro_.rs | 4 +-- 3 files changed, 53 insertions(+), 10 deletions(-) create mode 100644 crates/completion/src/render/const_.rs (limited to 'crates/completion/src/render') diff --git a/crates/completion/src/render/const_.rs b/crates/completion/src/render/const_.rs new file mode 100644 index 000000000..d88bfa07f --- /dev/null +++ b/crates/completion/src/render/const_.rs @@ -0,0 +1,47 @@ +use hir::HasSource; +use syntax::{ + ast::{Const, NameOwner}, + display::const_label, +}; + +use crate::{ + item::{CompletionItem, CompletionItemKind, CompletionKind}, + render::RenderContext, +}; + +#[derive(Debug)] +pub(crate) struct ConstRender<'a> { + ctx: RenderContext<'a>, + const_: hir::Const, + ast_node: Const, +} + +impl<'a> ConstRender<'a> { + pub(crate) fn new(ctx: RenderContext<'a>, const_: hir::Const) -> ConstRender<'a> { + let ast_node = const_.source(ctx.db()).value; + ConstRender { ctx, const_, ast_node } + } + + pub(crate) fn render(self) -> Option { + let name = self.name()?; + let detail = self.detail(); + + let item = CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name) + .kind(CompletionItemKind::Const) + .set_documentation(self.ctx.docs(self.const_)) + .set_deprecated(self.ctx.is_deprecated(self.const_)) + .detail(detail) + .build(); + + Some(item) + } + + fn name(&self) -> Option { + let ast_node = self.const_.source(self.ctx.db()).value; + ast_node.name().map(|name| name.text().to_string()) + } + + fn detail(&self) -> String { + const_label(&self.ast_node) + } +} diff --git a/crates/completion/src/render/function.rs b/crates/completion/src/render/function.rs index 16f15e22c..d22081236 100644 --- a/crates/completion/src/render/function.rs +++ b/crates/completion/src/render/function.rs @@ -1,4 +1,4 @@ -use hir::{Documentation, HasAttrs, HasSource, Type}; +use hir::{HasSource, Type}; use syntax::{ast::Fn, display::function_declaration}; use crate::{ @@ -30,7 +30,7 @@ impl<'a> FunctionRender<'a> { let params = self.params(); CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), self.name.clone()) .kind(self.kind()) - .set_documentation(self.docs()) + .set_documentation(self.ctx.docs(self.fn_)) .set_deprecated(self.ctx.is_deprecated(self.fn_)) .detail(self.detail()) .add_call_parens(self.ctx.completion, self.name, params) @@ -45,8 +45,8 @@ impl<'a> FunctionRender<'a> { if let Some(derefed_ty) = ty.remove_ref() { for (name, local) in self.ctx.completion.locals.iter() { if name == arg && local.ty(self.ctx.db()) == derefed_ty { - return (if ty.is_mutable_reference() { "&mut " } else { "&" }).to_string() - + &arg.to_string(); + let mutability = if ty.is_mutable_reference() { "&mut " } else { "&" }; + return format!("{}{}", mutability, arg); } } } @@ -80,8 +80,4 @@ impl<'a> FunctionRender<'a> { CompletionItemKind::Function } } - - fn docs(&self) -> Option { - self.fn_.docs(self.ctx.db()) - } } diff --git a/crates/completion/src/render/macro_.rs b/crates/completion/src/render/macro_.rs index bcf94f47e..0ad8c03b3 100644 --- a/crates/completion/src/render/macro_.rs +++ b/crates/completion/src/render/macro_.rs @@ -1,4 +1,4 @@ -use hir::{Documentation, HasAttrs, HasSource}; +use hir::{Documentation, HasSource}; use syntax::display::macro_label; use test_utils::mark; @@ -23,7 +23,7 @@ impl<'a> MacroRender<'a> { name: String, macro_: hir::MacroDef, ) -> MacroRender<'a> { - let docs = macro_.docs(ctx.db()); + let docs = ctx.docs(macro_); let docs_str = docs.as_ref().map_or("", |s| s.as_str()); let (bra, ket) = guess_macro_braces(&name, docs_str); -- cgit v1.2.3 From 15b16917fcd55068d9aba3d4b5d87763ec5deb69 Mon Sep 17 00:00:00 2001 From: Igor Aleksanov Date: Sun, 1 Nov 2020 13:10:02 +0300 Subject: Add TypeAliasRender --- crates/completion/src/render/const_.rs | 3 +- crates/completion/src/render/type_alias.rs | 46 ++++++++++++++++++++++++++++++ 2 files changed, 47 insertions(+), 2 deletions(-) create mode 100644 crates/completion/src/render/type_alias.rs (limited to 'crates/completion/src/render') diff --git a/crates/completion/src/render/const_.rs b/crates/completion/src/render/const_.rs index d88bfa07f..829eb574d 100644 --- a/crates/completion/src/render/const_.rs +++ b/crates/completion/src/render/const_.rs @@ -37,8 +37,7 @@ impl<'a> ConstRender<'a> { } fn name(&self) -> Option { - let ast_node = self.const_.source(self.ctx.db()).value; - ast_node.name().map(|name| name.text().to_string()) + self.ast_node.name().map(|name| name.text().to_string()) } fn detail(&self) -> String { diff --git a/crates/completion/src/render/type_alias.rs b/crates/completion/src/render/type_alias.rs new file mode 100644 index 000000000..378aa8c67 --- /dev/null +++ b/crates/completion/src/render/type_alias.rs @@ -0,0 +1,46 @@ +use hir::HasSource; +use syntax::{ + ast::{NameOwner, TypeAlias}, + display::type_label, +}; + +use crate::{ + item::{CompletionItem, CompletionItemKind, CompletionKind}, + render::RenderContext, +}; + +#[derive(Debug)] +pub(crate) struct TypeAliasRender<'a> { + ctx: RenderContext<'a>, + type_alias: hir::TypeAlias, + ast_node: TypeAlias, +} + +impl<'a> TypeAliasRender<'a> { + pub(crate) fn new(ctx: RenderContext<'a>, type_alias: hir::TypeAlias) -> TypeAliasRender<'a> { + let ast_node = type_alias.source(ctx.db()).value; + TypeAliasRender { ctx, type_alias, ast_node } + } + + pub(crate) fn render(self) -> Option { + let name = self.name()?; + let detail = self.detail(); + + let item = CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name) + .kind(CompletionItemKind::TypeAlias) + .set_documentation(self.ctx.docs(self.type_alias)) + .set_deprecated(self.ctx.is_deprecated(self.type_alias)) + .detail(detail) + .build(); + + Some(item) + } + + fn name(&self) -> Option { + self.ast_node.name().map(|name| name.text().to_string()) + } + + fn detail(&self) -> String { + type_label(&self.ast_node) + } +} -- cgit v1.2.3 From 97a504805d4b0cf8b48bc5052453b2b2f3298449 Mon Sep 17 00:00:00 2001 From: Igor Aleksanov Date: Sun, 1 Nov 2020 13:36:30 +0300 Subject: Move rendering tests to the render module --- crates/completion/src/render/enum_variant.rs | 74 ++++++++++ crates/completion/src/render/function.rs | 210 +++++++++++++++++++++++++++ crates/completion/src/render/macro_.rs | 90 ++++++++++++ 3 files changed, 374 insertions(+) (limited to 'crates/completion/src/render') diff --git a/crates/completion/src/render/enum_variant.rs b/crates/completion/src/render/enum_variant.rs index 26cfdfeea..bc96cc303 100644 --- a/crates/completion/src/render/enum_variant.rs +++ b/crates/completion/src/render/enum_variant.rs @@ -93,3 +93,77 @@ impl<'a> EnumVariantRender<'a> { } } } + +#[cfg(test)] +mod tests { + use test_utils::mark; + + use crate::test_utils::check_edit; + + #[test] + fn inserts_parens_for_tuple_enums() { + mark::check!(inserts_parens_for_tuple_enums); + check_edit( + "Some", + r#" +enum Option { Some(T), None } +use Option::*; +fn main() -> Option { + Som<|> +} +"#, + r#" +enum Option { Some(T), None } +use Option::*; +fn main() -> Option { + Some($0) +} +"#, + ); + check_edit( + "Some", + r#" +enum Option { Some(T), None } +use Option::*; +fn main(value: Option) { + match value { + Som<|> + } +} +"#, + r#" +enum Option { Some(T), None } +use Option::*; +fn main(value: Option) { + match value { + Some($0) + } +} +"#, + ); + } + + #[test] + fn dont_duplicate_pattern_parens() { + mark::check!(dont_duplicate_pattern_parens); + check_edit( + "Var", + r#" +enum E { Var(i32) } +fn main() { + match E::Var(92) { + E::<|>(92) => (), + } +} +"#, + r#" +enum E { Var(i32) } +fn main() { + match E::Var(92) { + E::Var(92) => (), + } +} +"#, + ); + } +} diff --git a/crates/completion/src/render/function.rs b/crates/completion/src/render/function.rs index d22081236..cf3852bf6 100644 --- a/crates/completion/src/render/function.rs +++ b/crates/completion/src/render/function.rs @@ -81,3 +81,213 @@ impl<'a> FunctionRender<'a> { } } } + +#[cfg(test)] +mod tests { + use test_utils::mark; + + use crate::{ + test_utils::{check_edit, check_edit_with_config}, + CompletionConfig, + }; + + #[test] + fn inserts_parens_for_function_calls() { + mark::check!(inserts_parens_for_function_calls); + check_edit( + "no_args", + r#" +fn no_args() {} +fn main() { no_<|> } +"#, + r#" +fn no_args() {} +fn main() { no_args()$0 } +"#, + ); + + check_edit( + "with_args", + r#" +fn with_args(x: i32, y: String) {} +fn main() { with_<|> } +"#, + r#" +fn with_args(x: i32, y: String) {} +fn main() { with_args(${1:x}, ${2:y})$0 } +"#, + ); + + check_edit( + "foo", + r#" +struct S; +impl S { + fn foo(&self) {} +} +fn bar(s: &S) { s.f<|> } +"#, + r#" +struct S; +impl S { + fn foo(&self) {} +} +fn bar(s: &S) { s.foo()$0 } +"#, + ); + + check_edit( + "foo", + r#" +struct S {} +impl S { + fn foo(&self, x: i32) {} +} +fn bar(s: &S) { + s.f<|> +} +"#, + r#" +struct S {} +impl S { + fn foo(&self, x: i32) {} +} +fn bar(s: &S) { + s.foo(${1:x})$0 +} +"#, + ); + } + + #[test] + fn suppress_arg_snippets() { + mark::check!(suppress_arg_snippets); + check_edit_with_config( + CompletionConfig { add_call_argument_snippets: false, ..CompletionConfig::default() }, + "with_args", + r#" +fn with_args(x: i32, y: String) {} +fn main() { with_<|> } +"#, + r#" +fn with_args(x: i32, y: String) {} +fn main() { with_args($0) } +"#, + ); + } + + #[test] + fn strips_underscores_from_args() { + check_edit( + "foo", + r#" +fn foo(_foo: i32, ___bar: bool, ho_ge_: String) {} +fn main() { f<|> } +"#, + r#" +fn foo(_foo: i32, ___bar: bool, ho_ge_: String) {} +fn main() { foo(${1:foo}, ${2:bar}, ${3:ho_ge_})$0 } +"#, + ); + } + + #[test] + fn insert_ref_when_matching_local_in_scope() { + check_edit( + "ref_arg", + r#" +struct Foo {} +fn ref_arg(x: &Foo) {} +fn main() { + let x = Foo {}; + ref_ar<|> +} +"#, + r#" +struct Foo {} +fn ref_arg(x: &Foo) {} +fn main() { + let x = Foo {}; + ref_arg(${1:&x})$0 +} +"#, + ); + } + + #[test] + fn insert_mut_ref_when_matching_local_in_scope() { + check_edit( + "ref_arg", + r#" +struct Foo {} +fn ref_arg(x: &mut Foo) {} +fn main() { + let x = Foo {}; + ref_ar<|> +} +"#, + r#" +struct Foo {} +fn ref_arg(x: &mut Foo) {} +fn main() { + let x = Foo {}; + ref_arg(${1:&mut x})$0 +} +"#, + ); + } + + #[test] + fn insert_ref_when_matching_local_in_scope_for_method() { + check_edit( + "apply_foo", + r#" +struct Foo {} +struct Bar {} +impl Bar { + fn apply_foo(&self, x: &Foo) {} +} + +fn main() { + let x = Foo {}; + let y = Bar {}; + y.<|> +} +"#, + r#" +struct Foo {} +struct Bar {} +impl Bar { + fn apply_foo(&self, x: &Foo) {} +} + +fn main() { + let x = Foo {}; + let y = Bar {}; + y.apply_foo(${1:&x})$0 +} +"#, + ); + } + + #[test] + fn trim_mut_keyword_in_func_completion() { + check_edit( + "take_mutably", + r#" +fn take_mutably(mut x: &i32) {} + +fn main() { + take_m<|> +} +"#, + r#" +fn take_mutably(mut x: &i32) {} + +fn main() { + take_mutably(${1:x})$0 +} +"#, + ); + } +} diff --git a/crates/completion/src/render/macro_.rs b/crates/completion/src/render/macro_.rs index 0ad8c03b3..6df121c66 100644 --- a/crates/completion/src/render/macro_.rs +++ b/crates/completion/src/render/macro_.rs @@ -114,3 +114,93 @@ fn guess_macro_braces(macro_name: &str, docs: &str) -> (&'static str, &'static s .unwrap(); (*bra, *ket) } + +#[cfg(test)] +mod tests { + use test_utils::mark; + + use crate::test_utils::check_edit; + + #[test] + fn dont_insert_macro_call_parens_unncessary() { + mark::check!(dont_insert_macro_call_parens_unncessary); + check_edit( + "frobnicate!", + r#" +//- /main.rs crate:main deps:foo +use foo::<|>; +//- /foo/lib.rs crate:foo +#[macro_export] +macro_rules frobnicate { () => () } +"#, + r#" +use foo::frobnicate; +"#, + ); + + check_edit( + "frobnicate!", + r#" +macro_rules frobnicate { () => () } +fn main() { frob<|>!(); } +"#, + r#" +macro_rules frobnicate { () => () } +fn main() { frobnicate!(); } +"#, + ); + } + + #[test] + fn guesses_macro_braces() { + check_edit( + "vec!", + r#" +/// Creates a [`Vec`] containing the arguments. +/// +/// ``` +/// let v = vec![1, 2, 3]; +/// assert_eq!(v[0], 1); +/// assert_eq!(v[1], 2); +/// assert_eq!(v[2], 3); +/// ``` +macro_rules! vec { () => {} } + +fn fn main() { v<|> } +"#, + r#" +/// Creates a [`Vec`] containing the arguments. +/// +/// ``` +/// let v = vec![1, 2, 3]; +/// assert_eq!(v[0], 1); +/// assert_eq!(v[1], 2); +/// assert_eq!(v[2], 3); +/// ``` +macro_rules! vec { () => {} } + +fn fn main() { vec![$0] } +"#, + ); + + check_edit( + "foo!", + r#" +/// Foo +/// +/// Don't call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`, +/// call as `let _=foo! { hello world };` +macro_rules! foo { () => {} } +fn main() { <|> } +"#, + r#" +/// Foo +/// +/// Don't call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`, +/// call as `let _=foo! { hello world };` +macro_rules! foo { () => {} } +fn main() { foo! {$0} } +"#, + ) + } +} -- cgit v1.2.3 From 2a214e15d38c7d97243e23e5e26fee5f4e26bb50 Mon Sep 17 00:00:00 2001 From: Igor Aleksanov Date: Sun, 1 Nov 2020 13:48:42 +0300 Subject: Add doc-comments to the new files --- crates/completion/src/render/const_.rs | 2 ++ crates/completion/src/render/enum_variant.rs | 2 ++ crates/completion/src/render/function.rs | 2 ++ crates/completion/src/render/macro_.rs | 8 +++++++- crates/completion/src/render/type_alias.rs | 2 ++ 5 files changed, 15 insertions(+), 1 deletion(-) (limited to 'crates/completion/src/render') diff --git a/crates/completion/src/render/const_.rs b/crates/completion/src/render/const_.rs index 829eb574d..3a1954211 100644 --- a/crates/completion/src/render/const_.rs +++ b/crates/completion/src/render/const_.rs @@ -1,3 +1,5 @@ +//! Renderer for `const` fields. + use hir::HasSource; use syntax::{ ast::{Const, NameOwner}, diff --git a/crates/completion/src/render/enum_variant.rs b/crates/completion/src/render/enum_variant.rs index bc96cc303..f8b151318 100644 --- a/crates/completion/src/render/enum_variant.rs +++ b/crates/completion/src/render/enum_variant.rs @@ -1,3 +1,5 @@ +//! Renderer for `enum` variants. + use hir::{HasAttrs, HirDisplay, ModPath, StructKind}; use itertools::Itertools; use test_utils::mark; diff --git a/crates/completion/src/render/function.rs b/crates/completion/src/render/function.rs index cf3852bf6..9d9bbe309 100644 --- a/crates/completion/src/render/function.rs +++ b/crates/completion/src/render/function.rs @@ -1,3 +1,5 @@ +//! Renderer for function calls. + use hir::{HasSource, Type}; use syntax::{ast::Fn, display::function_declaration}; diff --git a/crates/completion/src/render/macro_.rs b/crates/completion/src/render/macro_.rs index 6df121c66..066185559 100644 --- a/crates/completion/src/render/macro_.rs +++ b/crates/completion/src/render/macro_.rs @@ -1,3 +1,5 @@ +//! Renderer for macro invocations. + use hir::{Documentation, HasSource}; use syntax::display::macro_label; use test_utils::mark; @@ -66,7 +68,11 @@ impl<'a> MacroRender<'a> { } fn label(&self) -> String { - format!("{}!{}…{}", self.name, self.bra, self.ket) + if self.needs_bang() && self.ctx.snippet_cap().is_some() { + format!("{}!{}…{}", self.name, self.bra, self.ket) + } else { + self.banged_name() + } } fn snippet(&self) -> String { diff --git a/crates/completion/src/render/type_alias.rs b/crates/completion/src/render/type_alias.rs index 378aa8c67..50a6d06c2 100644 --- a/crates/completion/src/render/type_alias.rs +++ b/crates/completion/src/render/type_alias.rs @@ -1,3 +1,5 @@ +//! Renderer for type aliases. + use hir::HasSource; use syntax::{ ast::{NameOwner, TypeAlias}, -- cgit v1.2.3 From 4d333ebb6372c135e5a723da899528cc22d07faa Mon Sep 17 00:00:00 2001 From: Igor Aleksanov Date: Tue, 3 Nov 2020 10:33:13 +0300 Subject: Get rid of do-er antipattern --- crates/completion/src/render/const_.rs | 13 ++++++++++--- crates/completion/src/render/enum_variant.rs | 15 ++++++++++++--- crates/completion/src/render/function.rs | 14 +++++++++++--- crates/completion/src/render/macro_.rs | 18 +++++++++++------- crates/completion/src/render/type_alias.rs | 13 ++++++++++--- 5 files changed, 54 insertions(+), 19 deletions(-) (limited to 'crates/completion/src/render') diff --git a/crates/completion/src/render/const_.rs b/crates/completion/src/render/const_.rs index 3a1954211..039bdabc0 100644 --- a/crates/completion/src/render/const_.rs +++ b/crates/completion/src/render/const_.rs @@ -11,20 +11,27 @@ use crate::{ render::RenderContext, }; +pub(crate) fn render_const<'a>( + ctx: RenderContext<'a>, + const_: hir::Const, +) -> Option { + ConstRender::new(ctx, const_).render() +} + #[derive(Debug)] -pub(crate) struct ConstRender<'a> { +struct ConstRender<'a> { ctx: RenderContext<'a>, const_: hir::Const, ast_node: Const, } impl<'a> ConstRender<'a> { - pub(crate) fn new(ctx: RenderContext<'a>, const_: hir::Const) -> ConstRender<'a> { + fn new(ctx: RenderContext<'a>, const_: hir::Const) -> ConstRender<'a> { let ast_node = const_.source(ctx.db()).value; ConstRender { ctx, const_, ast_node } } - pub(crate) fn render(self) -> Option { + fn render(self) -> Option { let name = self.name()?; let detail = self.detail(); diff --git a/crates/completion/src/render/enum_variant.rs b/crates/completion/src/render/enum_variant.rs index f8b151318..fd412ed0e 100644 --- a/crates/completion/src/render/enum_variant.rs +++ b/crates/completion/src/render/enum_variant.rs @@ -9,8 +9,17 @@ use crate::{ render::{builder_ext::Params, RenderContext}, }; +pub(crate) fn render_enum_variant<'a>( + ctx: RenderContext<'a>, + local_name: Option, + variant: hir::EnumVariant, + path: Option, +) -> CompletionItem { + EnumVariantRender::new(ctx, local_name, variant, path).render() +} + #[derive(Debug)] -pub(crate) struct EnumVariantRender<'a> { +struct EnumVariantRender<'a> { ctx: RenderContext<'a>, name: String, variant: hir::EnumVariant, @@ -21,7 +30,7 @@ pub(crate) struct EnumVariantRender<'a> { } impl<'a> EnumVariantRender<'a> { - pub(crate) fn new( + fn new( ctx: RenderContext<'a>, local_name: Option, variant: hir::EnumVariant, @@ -51,7 +60,7 @@ impl<'a> EnumVariantRender<'a> { } } - pub(crate) fn render(self) -> CompletionItem { + fn render(self) -> CompletionItem { let mut builder = CompletionItem::new( CompletionKind::Reference, self.ctx.source_range(), diff --git a/crates/completion/src/render/function.rs b/crates/completion/src/render/function.rs index 9d9bbe309..4fa6eafd7 100644 --- a/crates/completion/src/render/function.rs +++ b/crates/completion/src/render/function.rs @@ -8,8 +8,16 @@ use crate::{ render::{builder_ext::Params, RenderContext}, }; +pub(crate) fn render_fn<'a>( + ctx: RenderContext<'a>, + local_name: Option, + fn_: hir::Function, +) -> CompletionItem { + FunctionRender::new(ctx, local_name, fn_).render() +} + #[derive(Debug)] -pub(crate) struct FunctionRender<'a> { +struct FunctionRender<'a> { ctx: RenderContext<'a>, name: String, fn_: hir::Function, @@ -17,7 +25,7 @@ pub(crate) struct FunctionRender<'a> { } impl<'a> FunctionRender<'a> { - pub(crate) fn new( + fn new( ctx: RenderContext<'a>, local_name: Option, fn_: hir::Function, @@ -28,7 +36,7 @@ impl<'a> FunctionRender<'a> { FunctionRender { ctx, name, fn_, ast_node } } - pub(crate) fn render(self) -> CompletionItem { + fn render(self) -> CompletionItem { let params = self.params(); CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), self.name.clone()) .kind(self.kind()) diff --git a/crates/completion/src/render/macro_.rs b/crates/completion/src/render/macro_.rs index 066185559..96be59cc3 100644 --- a/crates/completion/src/render/macro_.rs +++ b/crates/completion/src/render/macro_.rs @@ -9,8 +9,16 @@ use crate::{ render::RenderContext, }; +pub(crate) fn render_macro<'a>( + ctx: RenderContext<'a>, + name: String, + macro_: hir::MacroDef, +) -> Option { + MacroRender::new(ctx, name, macro_).render() +} + #[derive(Debug)] -pub(crate) struct MacroRender<'a> { +struct MacroRender<'a> { ctx: RenderContext<'a>, name: String, macro_: hir::MacroDef, @@ -20,11 +28,7 @@ pub(crate) struct MacroRender<'a> { } impl<'a> MacroRender<'a> { - pub(crate) fn new( - ctx: RenderContext<'a>, - name: String, - macro_: hir::MacroDef, - ) -> MacroRender<'a> { + fn new(ctx: RenderContext<'a>, name: String, macro_: hir::MacroDef) -> MacroRender<'a> { let docs = ctx.docs(macro_); let docs_str = docs.as_ref().map_or("", |s| s.as_str()); let (bra, ket) = guess_macro_braces(&name, docs_str); @@ -32,7 +36,7 @@ impl<'a> MacroRender<'a> { MacroRender { ctx, name, macro_, docs, bra, ket } } - pub(crate) fn render(&self) -> Option { + fn render(&self) -> Option { // FIXME: Currently proc-macro do not have ast-node, // such that it does not have source if self.macro_.is_proc_macro() { diff --git a/crates/completion/src/render/type_alias.rs b/crates/completion/src/render/type_alias.rs index 50a6d06c2..9605c7fa9 100644 --- a/crates/completion/src/render/type_alias.rs +++ b/crates/completion/src/render/type_alias.rs @@ -11,20 +11,27 @@ use crate::{ render::RenderContext, }; +pub(crate) fn render_type_alias<'a>( + ctx: RenderContext<'a>, + type_alias: hir::TypeAlias, +) -> Option { + TypeAliasRender::new(ctx, type_alias).render() +} + #[derive(Debug)] -pub(crate) struct TypeAliasRender<'a> { +struct TypeAliasRender<'a> { ctx: RenderContext<'a>, type_alias: hir::TypeAlias, ast_node: TypeAlias, } impl<'a> TypeAliasRender<'a> { - pub(crate) fn new(ctx: RenderContext<'a>, type_alias: hir::TypeAlias) -> TypeAliasRender<'a> { + fn new(ctx: RenderContext<'a>, type_alias: hir::TypeAlias) -> TypeAliasRender<'a> { let ast_node = type_alias.source(ctx.db()).value; TypeAliasRender { ctx, type_alias, ast_node } } - pub(crate) fn render(self) -> Option { + fn render(self) -> Option { let name = self.name()?; let detail = self.detail(); -- cgit v1.2.3