crates/ide_completion/src/render/macro_.rs

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