crates/ide_completion/src/render/enum_variant.rs

   1 //! Renderer for `enum` variants.
   2
   3 use std::iter;
   4
   5 use hir::{HasAttrs, HirDisplay};
   6 use ide_db::SymbolKind;
   7 use itertools::Itertools;
   8
   9 use crate::{
  10     item::{CompletionItem, ImportEdit},
  11     render::{builder_ext::Params, compute_ref_match, compute_type_match, RenderContext},
  12     CompletionRelevance,
  13 };
  14
  15 pub(crate) fn render_variant(
  16     ctx: RenderContext<'_>,
  17     import_to_add: Option<ImportEdit>,
  18     local_name: Option<hir::Name>,
  19     variant: hir::Variant,
  20     path: Option<hir::ModPath>,
  21 ) -> CompletionItem {
  22     let _p = profile::span("render_enum_variant");
  23     EnumRender::new(ctx, local_name, variant, path).render(import_to_add)
  24 }
  25
  26 #[derive(Debug)]
  27 struct EnumRender<'a> {
  28     ctx: RenderContext<'a>,
  29     variant: hir::Variant,
  30     path: Option<hir::ModPath>,
  31     qualified_name: hir::ModPath,
  32     short_qualified_name: hir::ModPath,
  33     variant_kind: hir::StructKind,
  34 }
  35
  36 impl<'a> EnumRender<'a> {
  37     fn new(
  38         ctx: RenderContext<'a>,
  39         local_name: Option<hir::Name>,
  40         variant: hir::Variant,
  41         path: Option<hir::ModPath>,
  42     ) -> EnumRender<'a> {
  43         let name = local_name.unwrap_or_else(|| variant.name(ctx.db()));
  44         let variant_kind = variant.kind(ctx.db());
  45
  46         let (qualified_name, short_qualified_name) = match &path {
  47             Some(path) => {
  48                 let short = hir::ModPath::from_segments(
  49                     hir::PathKind::Plain,
  50                     path.segments().iter().skip(path.segments().len().saturating_sub(2)).cloned(),
  51                 );
  52                 (path.clone(), short)
  53             }
  54             None => (
  55                 hir::ModPath::from_segments(hir::PathKind::Plain, iter::once(name.clone())),
  56                 hir::ModPath::from_segments(hir::PathKind::Plain, iter::once(name)),
  57             ),
  58         };
  59
  60         EnumRender { ctx, variant, path, qualified_name, short_qualified_name, variant_kind }
  61     }
  62     fn render(self, import_to_add: Option<ImportEdit>) -> CompletionItem {
  63         let mut item = CompletionItem::new(
  64             SymbolKind::Variant,
  65             self.ctx.source_range(),
  66             self.qualified_name.to_string(),
  67         );
  68         item.set_documentation(self.variant.docs(self.ctx.db()))
  69             .set_deprecated(self.ctx.is_deprecated(self.variant))
  70             .detail(self.detail());
  71
  72         if let Some(import_to_add) = import_to_add {
  73             item.add_import(import_to_add);
  74         }
  75
  76         if self.variant_kind == hir::StructKind::Tuple {
  77             cov_mark::hit!(inserts_parens_for_tuple_enums);
  78             let params = Params::Anonymous(self.variant.fields(self.ctx.db()).len());
  79             item.add_call_parens(
  80                 self.ctx.completion,
  81                 self.short_qualified_name.to_string(),
  82                 params,
  83             );
  84         } else if self.path.is_some() {
  85             item.lookup_by(self.short_qualified_name.to_string());
  86         }
  87
  88         let ty = self.variant.parent_enum(self.ctx.completion.db).ty(self.ctx.completion.db);
  89         item.set_relevance(CompletionRelevance {
  90             type_match: compute_type_match(self.ctx.completion, &ty),
  91             ..CompletionRelevance::default()
  92         });
  93
  94         if let Some(ref_match) = compute_ref_match(self.ctx.completion, &ty) {
  95             item.ref_match(ref_match);
  96         }
  97
  98         item.build()
  99     }
 100
 101     fn detail(&self) -> String {
 102         let detail_types = self
 103             .variant
 104             .fields(self.ctx.db())
 105             .into_iter()
 106             .map(|field| (field.name(self.ctx.db()), field.ty(self.ctx.db())));
 107
 108         match self.variant_kind {
 109             hir::StructKind::Tuple | hir::StructKind::Unit => format!(
 110                 "({})",
 111                 detail_types.map(|(_, t)| t.display(self.ctx.db()).to_string()).format(", ")
 112             ),
 113             hir::StructKind::Record => format!(
 114                 "{{ {} }}",
 115                 detail_types
 116                     .map(|(n, t)| format!("{}: {}", n, t.display(self.ctx.db()).to_string()))
 117                     .format(", ")
 118             ),
 119         }
 120     }
 121 }
 122
 123 #[cfg(test)]
 124 mod tests {
 125     use crate::tests::check_edit;
 126
 127     #[test]
 128     fn inserts_parens_for_tuple_enums() {
 129         cov_mark::check!(inserts_parens_for_tuple_enums);
 130         check_edit(
 131             "Some",
 132             r#"
 133 enum Option<T> { Some(T), None }
 134 use Option::*;
 135 fn main() -> Option<i32> {
 136     Som$0
 137 }
 138 "#,
 139             r#"
 140 enum Option<T> { Some(T), None }
 141 use Option::*;
 142 fn main() -> Option<i32> {
 143     Some($0)
 144 }
 145 "#,
 146         );
 147     }
 148 }