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, SmolStr};
   6
   7 use crate::{
   8     context::CallKind,
   9     item::{CompletionItem, 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: SmolStr,
  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_smol_str();
  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 source_range = if self.ctx.completion.is_immediately_after_macro_bang() {
  45             cov_mark::hit!(completes_macro_call_if_cursor_at_bang_token);
  46             self.ctx.completion.token.parent().map(|it| it.text_range())
  47         } else {
  48             Some(self.ctx.source_range())
  49         }?;
  50         let mut item = CompletionItem::new(SymbolKind::Macro, source_range, self.label());
  51         item.set_documentation(self.docs.clone())
  52             .set_deprecated(self.ctx.is_deprecated(self.macro_))
  53             .set_detail(self.detail());
  54
  55         if let Some(import_to_add) = import_to_add {
  56             item.add_import(import_to_add);
  57         }
  58
  59         let needs_bang = !(self.ctx.completion.in_use_tree()
  60             || matches!(self.ctx.completion.path_call_kind(), Some(CallKind::Mac)));
  61         let has_parens = self.ctx.completion.path_call_kind().is_some();
  62
  63         match self.ctx.snippet_cap() {
  64             Some(cap) if needs_bang && !has_parens => {
  65                 let snippet = format!("{}!{}$0{}", self.name, self.bra, self.ket);
  66                 let lookup = self.banged_name();
  67                 item.insert_snippet(cap, snippet).lookup_by(lookup);
  68             }
  69             _ if needs_bang => {
  70                 let lookup = self.banged_name();
  71                 item.insert_text(self.banged_name()).lookup_by(lookup);
  72             }
  73             _ => {
  74                 cov_mark::hit!(dont_insert_macro_call_parens_unncessary);
  75                 item.insert_text(&*self.name);
  76             }
  77         };
  78
  79         Some(item.build())
  80     }
  81
  82     fn needs_bang(&self) -> bool {
  83         !self.ctx.completion.in_use_tree()
  84             && !matches!(self.ctx.completion.path_call_kind(), Some(CallKind::Mac))
  85     }
  86
  87     fn label(&self) -> SmolStr {
  88         if self.needs_bang() && self.ctx.snippet_cap().is_some() {
  89             SmolStr::from_iter([&*self.name, "!", self.bra, "…", self.ket])
  90         } else if self.macro_.kind() == hir::MacroKind::Derive {
  91             self.name.clone()
  92         } else {
  93             self.banged_name()
  94         }
  95     }
  96
  97     fn banged_name(&self) -> SmolStr {
  98         SmolStr::from_iter([&*self.name, "!"])
  99     }
 100
 101     fn detail(&self) -> Option<String> {
 102         let ast_node = self.macro_.source(self.ctx.db())?.value.left()?;
 103         Some(macro_label(&ast_node))
 104     }
 105 }
 106
 107 fn guess_macro_braces(macro_name: &str, docs: &str) -> (&'static str, &'static str) {
 108     let mut votes = [0, 0, 0];
 109     for (idx, s) in docs.match_indices(&macro_name) {
 110         let (before, after) = (&docs[..idx], &docs[idx + s.len()..]);
 111         // Ensure to match the full word
 112         if after.starts_with('!')
 113             && !before.ends_with(|c: char| c == '_' || c.is_ascii_alphanumeric())
 114         {
 115             // It may have spaces before the braces like `foo! {}`
 116             match after[1..].chars().find(|&c| !c.is_whitespace()) {
 117                 Some('{') => votes[0] += 1,
 118                 Some('[') => votes[1] += 1,
 119                 Some('(') => votes[2] += 1,
 120                 _ => {}
 121             }
 122         }
 123     }
 124
 125     // Insert a space before `{}`.
 126     // We prefer the last one when some votes equal.
 127     let (_vote, (bra, ket)) = votes
 128         .iter()
 129         .zip(&[(" {", "}"), ("[", "]"), ("(", ")")])
 130         .max_by_key(|&(&vote, _)| vote)
 131         .unwrap();
 132     (*bra, *ket)
 133 }
 134
 135 #[cfg(test)]
 136 mod tests {
 137     use crate::tests::check_edit;
 138
 139     #[test]
 140     fn dont_insert_macro_call_parens_unncessary() {
 141         cov_mark::check!(dont_insert_macro_call_parens_unncessary);
 142         check_edit(
 143             "frobnicate!",
 144             r#"
 145 //- /main.rs crate:main deps:foo
 146 use foo::$0;
 147 //- /foo/lib.rs crate:foo
 148 #[macro_export]
 149 macro_rules! frobnicate { () => () }
 150 "#,
 151             r#"
 152 use foo::frobnicate;
 153 "#,
 154         );
 155
 156         check_edit(
 157             "frobnicate!",
 158             r#"
 159 macro_rules! frobnicate { () => () }
 160 fn main() { frob$0!(); }
 161 "#,
 162             r#"
 163 macro_rules! frobnicate { () => () }
 164 fn main() { frobnicate!(); }
 165 "#,
 166         );
 167     }
 168
 169     #[test]
 170     fn add_bang_to_parens() {
 171         check_edit(
 172             "frobnicate!",
 173             r#"
 174 macro_rules! frobnicate { () => () }
 175 fn main() {
 176     frob$0()
 177 }
 178 "#,
 179             r#"
 180 macro_rules! frobnicate { () => () }
 181 fn main() {
 182     frobnicate!()
 183 }
 184 "#,
 185         );
 186     }
 187
 188     #[test]
 189     fn guesses_macro_braces() {
 190         check_edit(
 191             "vec!",
 192             r#"
 193 /// Creates a [`Vec`] containing the arguments.
 194 ///
 195 /// ```
 196 /// let v = vec![1, 2, 3];
 197 /// assert_eq!(v[0], 1);
 198 /// assert_eq!(v[1], 2);
 199 /// assert_eq!(v[2], 3);
 200 /// ```
 201 macro_rules! vec { () => {} }
 202
 203 fn main() { v$0 }
 204 "#,
 205             r#"
 206 /// Creates a [`Vec`] containing the arguments.
 207 ///
 208 /// ```
 209 /// let v = vec![1, 2, 3];
 210 /// assert_eq!(v[0], 1);
 211 /// assert_eq!(v[1], 2);
 212 /// assert_eq!(v[2], 3);
 213 /// ```
 214 macro_rules! vec { () => {} }
 215
 216 fn main() { vec![$0] }
 217 "#,
 218         );
 219
 220         check_edit(
 221             "foo!",
 222             r#"
 223 /// Foo
 224 ///
 225 /// Don't call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`,
 226 /// call as `let _=foo!  { hello world };`
 227 macro_rules! foo { () => {} }
 228 fn main() { $0 }
 229 "#,
 230             r#"
 231 /// Foo
 232 ///
 233 /// Don't call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`,
 234 /// call as `let _=foo!  { hello world };`
 235 macro_rules! foo { () => {} }
 236 fn main() { foo! {$0} }
 237 "#,
 238         )
 239     }
 240
 241     #[test]
 242     fn completes_macro_call_if_cursor_at_bang_token() {
 243         // Regression test for https://github.com/rust-analyzer/rust-analyzer/issues/9904
 244         cov_mark::check!(completes_macro_call_if_cursor_at_bang_token);
 245         check_edit(
 246             "foo!",
 247             r#"
 248 macro_rules! foo {
 249     () => {}
 250 }
 251
 252 fn main() {
 253     foo!$0
 254 }
 255 "#,
 256             r#"
 257 macro_rules! foo {
 258     () => {}
 259 }
 260
 261 fn main() {
 262     foo!($0)
 263 }
 264 "#,
 265         );
 266     }
 267 }