crates/ide_completion/src/render/macro_.rs

   1 //! Renderer for macro invocations.
   2
   3 use hir::HasSource;
   4 use ide_db::SymbolKind;
   5 use syntax::display::macro_label;
   6
   7 use crate::{
   8     context::CallKind,
   9     item::{CompletionItem, CompletionKind, ImportEdit},
  10     render::RenderContext,
  11 };
  12
  13 pub(crate) fn render_macro(
  14     ctx: RenderContext<'_>,
  15     import_to_add: Option<ImportEdit>,
  16     name: hir::Name,
  17     macro_: hir::MacroDef,
  18 ) -> Option<CompletionItem> {
  19     let _p = profile::span("render_macro");
  20     MacroRender::new(ctx, name, macro_).render(import_to_add)
  21 }
  22
  23 #[derive(Debug)]
  24 struct MacroRender<'a> {
  25     ctx: RenderContext<'a>,
  26     name: String,
  27     macro_: hir::MacroDef,
  28     docs: Option<hir::Documentation>,
  29     bra: &'static str,
  30     ket: &'static str,
  31 }
  32
  33 impl<'a> MacroRender<'a> {
  34     fn new(ctx: RenderContext<'a>, name: hir::Name, macro_: hir::MacroDef) -> MacroRender<'a> {
  35         let name = name.to_string();
  36         let docs = ctx.docs(macro_);
  37         let docs_str = docs.as_ref().map_or("", |s| s.as_str());
  38         let (bra, ket) = guess_macro_braces(&name, docs_str);
  39
  40         MacroRender { ctx, name, macro_, docs, bra, ket }
  41     }
  42
  43     fn render(&self, import_to_add: Option<ImportEdit>) -> Option<CompletionItem> {
  44         let mut item =
  45             CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), &self.label());
  46         item.kind(SymbolKind::Macro)
  47             .set_documentation(self.docs.clone())
  48             .set_deprecated(self.ctx.is_deprecated(self.macro_))
  49             .add_import(import_to_add)
  50             .set_detail(self.detail());
  51
  52         let needs_bang = !(self.ctx.completion.in_use_tree()
  53             || matches!(self.ctx.completion.path_call_kind(), Some(CallKind::Mac)));
  54         let has_parens = self.ctx.completion.path_call_kind().is_some();
  55
  56         match self.ctx.snippet_cap() {
  57             Some(cap) if needs_bang && !has_parens => {
  58                 let snippet = format!("{}!{}$0{}", self.name, self.bra, self.ket);
  59                 let lookup = self.banged_name();
  60                 item.insert_snippet(cap, snippet).lookup_by(lookup);
  61             }
  62             _ if needs_bang => {
  63                 let lookup = self.banged_name();
  64                 item.insert_text(self.banged_name()).lookup_by(lookup);
  65             }
  66             _ => {
  67                 cov_mark::hit!(dont_insert_macro_call_parens_unncessary);
  68                 item.insert_text(&self.name);
  69             }
  70         };
  71
  72         Some(item.build())
  73     }
  74
  75     fn needs_bang(&self) -> bool {
  76         !self.ctx.completion.in_use_tree()
  77             && !matches!(self.ctx.completion.path_call_kind(), Some(CallKind::Mac))
  78     }
  79
  80     fn label(&self) -> String {
  81         if self.needs_bang() && self.ctx.snippet_cap().is_some() {
  82             format!("{}!{}…{}", self.name, self.bra, self.ket)
  83         } else if self.macro_.kind() == hir::MacroKind::Derive {
  84             self.name.to_string()
  85         } else {
  86             self.banged_name()
  87         }
  88     }
  89
  90     fn banged_name(&self) -> String {
  91         format!("{}!", self.name)
  92     }
  93
  94     fn detail(&self) -> Option<String> {
  95         let ast_node = self.macro_.source(self.ctx.db())?.value.left()?;
  96         Some(macro_label(&ast_node))
  97     }
  98 }
  99
 100 fn guess_macro_braces(macro_name: &str, docs: &str) -> (&'static str, &'static str) {
 101     let mut votes = [0, 0, 0];
 102     for (idx, s) in docs.match_indices(&macro_name) {
 103         let (before, after) = (&docs[..idx], &docs[idx + s.len()..]);
 104         // Ensure to match the full word
 105         if after.starts_with('!')
 106             && !before.ends_with(|c: char| c == '_' || c.is_ascii_alphanumeric())
 107         {
 108             // It may have spaces before the braces like `foo! {}`
 109             match after[1..].chars().find(|&c| !c.is_whitespace()) {
 110                 Some('{') => votes[0] += 1,
 111                 Some('[') => votes[1] += 1,
 112                 Some('(') => votes[2] += 1,
 113                 _ => {}
 114             }
 115         }
 116     }
 117
 118     // Insert a space before `{}`.
 119     // We prefer the last one when some votes equal.
 120     let (_vote, (bra, ket)) = votes
 121         .iter()
 122         .zip(&[(" {", "}"), ("[", "]"), ("(", ")")])
 123         .max_by_key(|&(&vote, _)| vote)
 124         .unwrap();
 125     (*bra, *ket)
 126 }
 127
 128 #[cfg(test)]
 129 mod tests {
 130     use crate::tests::check_edit;
 131
 132     #[test]
 133     fn dont_insert_macro_call_parens_unncessary() {
 134         cov_mark::check!(dont_insert_macro_call_parens_unncessary);
 135         check_edit(
 136             "frobnicate!",
 137             r#"
 138 //- /main.rs crate:main deps:foo
 139 use foo::$0;
 140 //- /foo/lib.rs crate:foo
 141 #[macro_export]
 142 macro_rules! frobnicate { () => () }
 143 "#,
 144             r#"
 145 use foo::frobnicate;
 146 "#,
 147         );
 148
 149         check_edit(
 150             "frobnicate!",
 151             r#"
 152 macro_rules! frobnicate { () => () }
 153 fn main() { frob$0!(); }
 154 "#,
 155             r#"
 156 macro_rules! frobnicate { () => () }
 157 fn main() { frobnicate!(); }
 158 "#,
 159         );
 160     }
 161
 162     #[test]
 163     fn add_bang_to_parens() {
 164         check_edit(
 165             "frobnicate!",
 166             r#"
 167 macro_rules! frobnicate { () => () }
 168 fn main() {
 169     frob$0()
 170 }
 171 "#,
 172             r#"
 173 macro_rules! frobnicate { () => () }
 174 fn main() {
 175     frobnicate!()
 176 }
 177 "#,
 178         );
 179     }
 180
 181     #[test]
 182     fn guesses_macro_braces() {
 183         check_edit(
 184             "vec!",
 185             r#"
 186 /// Creates a [`Vec`] containing the arguments.
 187 ///
 188 /// ```
 189 /// let v = vec![1, 2, 3];
 190 /// assert_eq!(v[0], 1);
 191 /// assert_eq!(v[1], 2);
 192 /// assert_eq!(v[2], 3);
 193 /// ```
 194 macro_rules! vec { () => {} }
 195
 196 fn main() { v$0 }
 197 "#,
 198             r#"
 199 /// Creates a [`Vec`] containing the arguments.
 200 ///
 201 /// ```
 202 /// let v = vec![1, 2, 3];
 203 /// assert_eq!(v[0], 1);
 204 /// assert_eq!(v[1], 2);
 205 /// assert_eq!(v[2], 3);
 206 /// ```
 207 macro_rules! vec { () => {} }
 208
 209 fn main() { vec![$0] }
 210 "#,
 211         );
 212
 213         check_edit(
 214             "foo!",
 215             r#"
 216 /// Foo
 217 ///
 218 /// Don't call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`,
 219 /// call as `let _=foo!  { hello world };`
 220 macro_rules! foo { () => {} }
 221 fn main() { $0 }
 222 "#,
 223             r#"
 224 /// Foo
 225 ///
 226 /// Don't call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`,
 227 /// call as `let _=foo!  { hello world };`
 228 macro_rules! foo { () => {} }
 229 fn main() { foo! {$0} }
 230 "#,
 231         )
 232     }
 233 }