4 files changed, 392 insertions, 0 deletions

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<String>),
+    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<ModPath>,
+    qualified_name: String,
+    short_qualified_name: String,
+    variant_kind: StructKind,
+}
+
+impl<'a> EnumVariantRender<'a> {
+    pub(crate) fn new(
+        ctx: RenderContext<'a>,
+        local_name: Option<String>,
+        variant: hir::EnumVariant,
+        path: Option<ModPath>,
+    ) -> 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<String>,
+        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<Documentation> {
+        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<Documentation>,
+    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<CompletionItem> {
+        // 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(&macro_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)
+}