crates/ide_completion/src/render/struct_literal.rs

   1 //! Renderer for `struct` literal.
   2
   3 use hir::{db::HirDatabase, HasAttrs, HasVisibility, Name, StructKind};
   4 use ide_db::helpers::SnippetCap;
   5 use itertools::Itertools;
   6
   7 use crate::{item::CompletionKind, render::RenderContext, CompletionItem, CompletionItemKind};
   8
   9 pub(crate) fn render_struct_literal(
  10     ctx: RenderContext<'_>,
  11     strukt: hir::Struct,
  12     local_name: Option<Name>,
  13 ) -> Option<CompletionItem> {
  14     let _p = profile::span("render_struct_literal");
  15
  16     let fields = strukt.fields(ctx.db());
  17     let (visible_fields, fields_omitted) = visible_fields(&ctx, &fields, strukt)?;
  18
  19     if fields_omitted {
  20         // If some fields are private you can't make `struct` literal.
  21         return None;
  22     }
  23
  24     let name = local_name.unwrap_or_else(|| strukt.name(ctx.db())).to_string();
  25     let literal = render_literal(&ctx, &name, strukt.kind(ctx.db()), &visible_fields)?;
  26
  27     Some(build_completion(ctx, name, literal, strukt))
  28 }
  29
  30 fn build_completion(
  31     ctx: RenderContext<'_>,
  32     name: String,
  33     literal: String,
  34     def: impl HasAttrs + Copy,
  35 ) -> CompletionItem {
  36     let mut item = CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), name + " {…}");
  37     item.kind(CompletionItemKind::Snippet)
  38         .set_documentation(ctx.docs(def))
  39         .set_deprecated(ctx.is_deprecated(def))
  40         .detail(&literal);
  41     match ctx.snippet_cap() {
  42         Some(snippet_cap) => item.insert_snippet(snippet_cap, literal),
  43         None => item.insert_text(literal),
  44     };
  45     item.build()
  46 }
  47
  48 fn render_literal(
  49     ctx: &RenderContext<'_>,
  50     name: &str,
  51     kind: StructKind,
  52     fields: &[hir::Field],
  53 ) -> Option<String> {
  54     let mut literal = match kind {
  55         StructKind::Tuple if ctx.snippet_cap().is_some() => render_tuple_as_literal(fields, name),
  56         StructKind::Record => render_record_as_literal(ctx.db(), ctx.snippet_cap(), fields, name),
  57         _ => return None,
  58     };
  59
  60     if ctx.snippet_cap().is_some() {
  61         literal.push_str("$0");
  62     }
  63     Some(literal)
  64 }
  65
  66 fn render_record_as_literal(
  67     db: &dyn HirDatabase,
  68     snippet_cap: Option<SnippetCap>,
  69     fields: &[hir::Field],
  70     name: &str,
  71 ) -> String {
  72     let fields = fields.iter();
  73     if snippet_cap.is_some() {
  74         format!(
  75             "{name} {{ {} }}",
  76             fields
  77                 .enumerate()
  78                 .map(|(idx, field)| format!("{}: ${{{}:()}}", field.name(db), idx + 1))
  79                 .format(", "),
  80             name = name
  81         )
  82     } else {
  83         format!(
  84             "{name} {{ {} }}",
  85             fields.map(|field| format!("{}: ()", field.name(db))).format(", "),
  86             name = name
  87         )
  88     }
  89 }
  90
  91 fn render_tuple_as_literal(fields: &[hir::Field], name: &str) -> String {
  92     format!(
  93         "{name}({})",
  94         fields.iter().enumerate().map(|(idx, _)| format!("${}", idx + 1)).format(", "),
  95         name = name
  96     )
  97 }
  98
  99 fn visible_fields(
 100     ctx: &RenderContext<'_>,
 101     fields: &[hir::Field],
 102     item: impl HasAttrs,
 103 ) -> Option<(Vec<hir::Field>, bool)> {
 104     let module = ctx.completion.scope.module()?;
 105     let n_fields = fields.len();
 106     let fields = fields
 107         .iter()
 108         .filter(|field| field.is_visible_from(ctx.db(), module))
 109         .copied()
 110         .collect::<Vec<_>>();
 111
 112     let fields_omitted =
 113         n_fields - fields.len() > 0 || item.attrs(ctx.db()).by_key("non_exhaustive").exists();
 114     Some((fields, fields_omitted))
 115 }