diff options
author | Zac Pullar-Strecker <[email protected]> | 2020-08-24 10:19:53 +0100 |
---|---|---|
committer | Zac Pullar-Strecker <[email protected]> | 2020-08-24 10:20:13 +0100 |
commit | 7bbca7a1b3f9293d2f5cc5745199bc5f8396f2f0 (patch) | |
tree | bdb47765991cb973b2cd5481a088fac636bd326c /crates/ide/src/completion/presentation.rs | |
parent | ca464650eeaca6195891199a93f4f76cf3e7e697 (diff) | |
parent | e65d48d1fb3d4d91d9dc1148a7a836ff5c9a3c87 (diff) |
Merge remote-tracking branch 'upstream/master' into 503-hover-doc-links
Diffstat (limited to 'crates/ide/src/completion/presentation.rs')
-rw-r--r-- | crates/ide/src/completion/presentation.rs | 1227 |
1 files changed, 1227 insertions, 0 deletions
diff --git a/crates/ide/src/completion/presentation.rs b/crates/ide/src/completion/presentation.rs new file mode 100644 index 000000000..3371aed2d --- /dev/null +++ b/crates/ide/src/completion/presentation.rs | |||
@@ -0,0 +1,1227 @@ | |||
1 | //! This modules takes care of rendering various definitions as completion items. | ||
2 | //! It also handles scoring (sorting) completions. | ||
3 | |||
4 | use hir::{Docs, HasAttrs, HasSource, HirDisplay, ModPath, ScopeDef, StructKind, Type}; | ||
5 | use itertools::Itertools; | ||
6 | use syntax::ast::NameOwner; | ||
7 | use test_utils::mark; | ||
8 | |||
9 | use crate::{ | ||
10 | completion::{ | ||
11 | completion_item::Builder, CompletionContext, CompletionItem, CompletionItemKind, | ||
12 | CompletionKind, Completions, | ||
13 | }, | ||
14 | display::{const_label, function_declaration, macro_label, type_label}, | ||
15 | CompletionScore, RootDatabase, | ||
16 | }; | ||
17 | |||
18 | impl Completions { | ||
19 | pub(crate) fn add_field(&mut self, ctx: &CompletionContext, field: hir::Field, ty: &Type) { | ||
20 | let is_deprecated = is_deprecated(field, ctx.db); | ||
21 | let name = field.name(ctx.db); | ||
22 | let mut completion_item = | ||
23 | CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.to_string()) | ||
24 | .kind(CompletionItemKind::Field) | ||
25 | .detail(ty.display(ctx.db).to_string()) | ||
26 | .set_documentation(field.docs(ctx.db)) | ||
27 | .set_deprecated(is_deprecated); | ||
28 | |||
29 | if let Some(score) = compute_score(ctx, &ty, &name.to_string()) { | ||
30 | completion_item = completion_item.set_score(score); | ||
31 | } | ||
32 | |||
33 | completion_item.add_to(self); | ||
34 | } | ||
35 | |||
36 | pub(crate) fn add_tuple_field(&mut self, ctx: &CompletionContext, field: usize, ty: &Type) { | ||
37 | CompletionItem::new(CompletionKind::Reference, ctx.source_range(), field.to_string()) | ||
38 | .kind(CompletionItemKind::Field) | ||
39 | .detail(ty.display(ctx.db).to_string()) | ||
40 | .add_to(self); | ||
41 | } | ||
42 | |||
43 | pub(crate) fn add_resolution( | ||
44 | &mut self, | ||
45 | ctx: &CompletionContext, | ||
46 | local_name: String, | ||
47 | resolution: &ScopeDef, | ||
48 | ) { | ||
49 | use hir::ModuleDef::*; | ||
50 | |||
51 | let completion_kind = match resolution { | ||
52 | ScopeDef::ModuleDef(BuiltinType(..)) => CompletionKind::BuiltinType, | ||
53 | _ => CompletionKind::Reference, | ||
54 | }; | ||
55 | |||
56 | let kind = match resolution { | ||
57 | ScopeDef::ModuleDef(Module(..)) => CompletionItemKind::Module, | ||
58 | ScopeDef::ModuleDef(Function(func)) => { | ||
59 | return self.add_function(ctx, *func, Some(local_name)); | ||
60 | } | ||
61 | ScopeDef::ModuleDef(Adt(hir::Adt::Struct(_))) => CompletionItemKind::Struct, | ||
62 | // FIXME: add CompletionItemKind::Union | ||
63 | ScopeDef::ModuleDef(Adt(hir::Adt::Union(_))) => CompletionItemKind::Struct, | ||
64 | ScopeDef::ModuleDef(Adt(hir::Adt::Enum(_))) => CompletionItemKind::Enum, | ||
65 | |||
66 | ScopeDef::ModuleDef(EnumVariant(var)) => { | ||
67 | return self.add_enum_variant(ctx, *var, Some(local_name)); | ||
68 | } | ||
69 | ScopeDef::ModuleDef(Const(..)) => CompletionItemKind::Const, | ||
70 | ScopeDef::ModuleDef(Static(..)) => CompletionItemKind::Static, | ||
71 | ScopeDef::ModuleDef(Trait(..)) => CompletionItemKind::Trait, | ||
72 | ScopeDef::ModuleDef(TypeAlias(..)) => CompletionItemKind::TypeAlias, | ||
73 | ScopeDef::ModuleDef(BuiltinType(..)) => CompletionItemKind::BuiltinType, | ||
74 | ScopeDef::GenericParam(..) => CompletionItemKind::TypeParam, | ||
75 | ScopeDef::Local(..) => CompletionItemKind::Binding, | ||
76 | // (does this need its own kind?) | ||
77 | ScopeDef::AdtSelfType(..) | ScopeDef::ImplSelfType(..) => CompletionItemKind::TypeParam, | ||
78 | ScopeDef::MacroDef(mac) => { | ||
79 | return self.add_macro(ctx, Some(local_name), *mac); | ||
80 | } | ||
81 | ScopeDef::Unknown => { | ||
82 | return self.add( | ||
83 | CompletionItem::new(CompletionKind::Reference, ctx.source_range(), local_name) | ||
84 | .kind(CompletionItemKind::UnresolvedReference), | ||
85 | ); | ||
86 | } | ||
87 | }; | ||
88 | |||
89 | let docs = match resolution { | ||
90 | ScopeDef::ModuleDef(Module(it)) => it.docs(ctx.db), | ||
91 | ScopeDef::ModuleDef(Adt(it)) => it.docs(ctx.db), | ||
92 | ScopeDef::ModuleDef(EnumVariant(it)) => it.docs(ctx.db), | ||
93 | ScopeDef::ModuleDef(Const(it)) => it.docs(ctx.db), | ||
94 | ScopeDef::ModuleDef(Static(it)) => it.docs(ctx.db), | ||
95 | ScopeDef::ModuleDef(Trait(it)) => it.docs(ctx.db), | ||
96 | ScopeDef::ModuleDef(TypeAlias(it)) => it.docs(ctx.db), | ||
97 | _ => None, | ||
98 | }; | ||
99 | |||
100 | let mut completion_item = | ||
101 | CompletionItem::new(completion_kind, ctx.source_range(), local_name.clone()); | ||
102 | if let ScopeDef::Local(local) = resolution { | ||
103 | let ty = local.ty(ctx.db); | ||
104 | if !ty.is_unknown() { | ||
105 | completion_item = completion_item.detail(ty.display(ctx.db).to_string()); | ||
106 | } | ||
107 | }; | ||
108 | |||
109 | if let ScopeDef::Local(local) = resolution { | ||
110 | if let Some(score) = compute_score(ctx, &local.ty(ctx.db), &local_name) { | ||
111 | completion_item = completion_item.set_score(score); | ||
112 | } | ||
113 | } | ||
114 | |||
115 | // Add `<>` for generic types | ||
116 | if ctx.is_path_type && !ctx.has_type_args && ctx.config.add_call_parenthesis { | ||
117 | if let Some(cap) = ctx.config.snippet_cap { | ||
118 | let has_non_default_type_params = match resolution { | ||
119 | ScopeDef::ModuleDef(Adt(it)) => it.has_non_default_type_params(ctx.db), | ||
120 | ScopeDef::ModuleDef(TypeAlias(it)) => it.has_non_default_type_params(ctx.db), | ||
121 | _ => false, | ||
122 | }; | ||
123 | if has_non_default_type_params { | ||
124 | mark::hit!(inserts_angle_brackets_for_generics); | ||
125 | completion_item = completion_item | ||
126 | .lookup_by(local_name.clone()) | ||
127 | .label(format!("{}<…>", local_name)) | ||
128 | .insert_snippet(cap, format!("{}<$0>", local_name)); | ||
129 | } | ||
130 | } | ||
131 | } | ||
132 | |||
133 | completion_item.kind(kind).set_documentation(docs).add_to(self) | ||
134 | } | ||
135 | |||
136 | pub(crate) fn add_macro( | ||
137 | &mut self, | ||
138 | ctx: &CompletionContext, | ||
139 | name: Option<String>, | ||
140 | macro_: hir::MacroDef, | ||
141 | ) { | ||
142 | // FIXME: Currently proc-macro do not have ast-node, | ||
143 | // such that it does not have source | ||
144 | if macro_.is_proc_macro() { | ||
145 | return; | ||
146 | } | ||
147 | |||
148 | let name = match name { | ||
149 | Some(it) => it, | ||
150 | None => return, | ||
151 | }; | ||
152 | |||
153 | let ast_node = macro_.source(ctx.db).value; | ||
154 | let detail = macro_label(&ast_node); | ||
155 | |||
156 | let docs = macro_.docs(ctx.db); | ||
157 | |||
158 | let mut builder = CompletionItem::new( | ||
159 | CompletionKind::Reference, | ||
160 | ctx.source_range(), | ||
161 | &format!("{}!", name), | ||
162 | ) | ||
163 | .kind(CompletionItemKind::Macro) | ||
164 | .set_documentation(docs.clone()) | ||
165 | .set_deprecated(is_deprecated(macro_, ctx.db)) | ||
166 | .detail(detail); | ||
167 | |||
168 | let needs_bang = ctx.use_item_syntax.is_none() && !ctx.is_macro_call; | ||
169 | builder = match ctx.config.snippet_cap { | ||
170 | Some(cap) if needs_bang => { | ||
171 | let docs = docs.as_ref().map_or("", |s| s.as_str()); | ||
172 | let (bra, ket) = guess_macro_braces(&name, docs); | ||
173 | builder | ||
174 | .insert_snippet(cap, format!("{}!{}$0{}", name, bra, ket)) | ||
175 | .label(format!("{}!{}…{}", name, bra, ket)) | ||
176 | .lookup_by(format!("{}!", name)) | ||
177 | } | ||
178 | None if needs_bang => builder.insert_text(format!("{}!", name)), | ||
179 | _ => { | ||
180 | mark::hit!(dont_insert_macro_call_parens_unncessary); | ||
181 | builder.insert_text(name) | ||
182 | } | ||
183 | }; | ||
184 | |||
185 | self.add(builder); | ||
186 | } | ||
187 | |||
188 | pub(crate) fn add_function( | ||
189 | &mut self, | ||
190 | ctx: &CompletionContext, | ||
191 | func: hir::Function, | ||
192 | local_name: Option<String>, | ||
193 | ) { | ||
194 | let name = local_name.unwrap_or_else(|| func.name(ctx.db).to_string()); | ||
195 | let ast_node = func.source(ctx.db).value; | ||
196 | |||
197 | let mut builder = | ||
198 | CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.clone()) | ||
199 | .kind(if func.self_param(ctx.db).is_some() { | ||
200 | CompletionItemKind::Method | ||
201 | } else { | ||
202 | CompletionItemKind::Function | ||
203 | }) | ||
204 | .set_documentation(func.docs(ctx.db)) | ||
205 | .set_deprecated(is_deprecated(func, ctx.db)) | ||
206 | .detail(function_declaration(&ast_node)); | ||
207 | |||
208 | let params = ast_node | ||
209 | .param_list() | ||
210 | .into_iter() | ||
211 | .flat_map(|it| it.params()) | ||
212 | .flat_map(|it| it.pat()) | ||
213 | .map(|pat| pat.to_string().trim_start_matches('_').into()) | ||
214 | .collect(); | ||
215 | |||
216 | builder = builder.add_call_parens(ctx, name, Params::Named(params)); | ||
217 | |||
218 | self.add(builder) | ||
219 | } | ||
220 | |||
221 | pub(crate) fn add_const(&mut self, ctx: &CompletionContext, constant: hir::Const) { | ||
222 | let ast_node = constant.source(ctx.db).value; | ||
223 | let name = match ast_node.name() { | ||
224 | Some(name) => name, | ||
225 | _ => return, | ||
226 | }; | ||
227 | let detail = const_label(&ast_node); | ||
228 | |||
229 | CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.text().to_string()) | ||
230 | .kind(CompletionItemKind::Const) | ||
231 | .set_documentation(constant.docs(ctx.db)) | ||
232 | .set_deprecated(is_deprecated(constant, ctx.db)) | ||
233 | .detail(detail) | ||
234 | .add_to(self); | ||
235 | } | ||
236 | |||
237 | pub(crate) fn add_type_alias(&mut self, ctx: &CompletionContext, type_alias: hir::TypeAlias) { | ||
238 | let type_def = type_alias.source(ctx.db).value; | ||
239 | let name = match type_def.name() { | ||
240 | Some(name) => name, | ||
241 | _ => return, | ||
242 | }; | ||
243 | let detail = type_label(&type_def); | ||
244 | |||
245 | CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.text().to_string()) | ||
246 | .kind(CompletionItemKind::TypeAlias) | ||
247 | .set_documentation(type_alias.docs(ctx.db)) | ||
248 | .set_deprecated(is_deprecated(type_alias, ctx.db)) | ||
249 | .detail(detail) | ||
250 | .add_to(self); | ||
251 | } | ||
252 | |||
253 | pub(crate) fn add_qualified_enum_variant( | ||
254 | &mut self, | ||
255 | ctx: &CompletionContext, | ||
256 | variant: hir::EnumVariant, | ||
257 | path: ModPath, | ||
258 | ) { | ||
259 | self.add_enum_variant_impl(ctx, variant, None, Some(path)) | ||
260 | } | ||
261 | |||
262 | pub(crate) fn add_enum_variant( | ||
263 | &mut self, | ||
264 | ctx: &CompletionContext, | ||
265 | variant: hir::EnumVariant, | ||
266 | local_name: Option<String>, | ||
267 | ) { | ||
268 | self.add_enum_variant_impl(ctx, variant, local_name, None) | ||
269 | } | ||
270 | |||
271 | fn add_enum_variant_impl( | ||
272 | &mut self, | ||
273 | ctx: &CompletionContext, | ||
274 | variant: hir::EnumVariant, | ||
275 | local_name: Option<String>, | ||
276 | path: Option<ModPath>, | ||
277 | ) { | ||
278 | let is_deprecated = is_deprecated(variant, ctx.db); | ||
279 | let name = local_name.unwrap_or_else(|| variant.name(ctx.db).to_string()); | ||
280 | let qualified_name = match &path { | ||
281 | Some(it) => it.to_string(), | ||
282 | None => name.to_string(), | ||
283 | }; | ||
284 | let detail_types = variant | ||
285 | .fields(ctx.db) | ||
286 | .into_iter() | ||
287 | .map(|field| (field.name(ctx.db), field.signature_ty(ctx.db))); | ||
288 | let variant_kind = variant.kind(ctx.db); | ||
289 | let detail = match variant_kind { | ||
290 | StructKind::Tuple | StructKind::Unit => format!( | ||
291 | "({})", | ||
292 | detail_types.map(|(_, t)| t.display(ctx.db).to_string()).format(", ") | ||
293 | ), | ||
294 | StructKind::Record => format!( | ||
295 | "{{ {} }}", | ||
296 | detail_types | ||
297 | .map(|(n, t)| format!("{}: {}", n, t.display(ctx.db).to_string())) | ||
298 | .format(", ") | ||
299 | ), | ||
300 | }; | ||
301 | let mut res = CompletionItem::new( | ||
302 | CompletionKind::Reference, | ||
303 | ctx.source_range(), | ||
304 | qualified_name.clone(), | ||
305 | ) | ||
306 | .kind(CompletionItemKind::EnumVariant) | ||
307 | .set_documentation(variant.docs(ctx.db)) | ||
308 | .set_deprecated(is_deprecated) | ||
309 | .detail(detail); | ||
310 | |||
311 | if path.is_some() { | ||
312 | res = res.lookup_by(name); | ||
313 | } | ||
314 | |||
315 | if variant_kind == StructKind::Tuple { | ||
316 | mark::hit!(inserts_parens_for_tuple_enums); | ||
317 | let params = Params::Anonymous(variant.fields(ctx.db).len()); | ||
318 | res = res.add_call_parens(ctx, qualified_name, params) | ||
319 | } | ||
320 | |||
321 | res.add_to(self); | ||
322 | } | ||
323 | } | ||
324 | |||
325 | pub(crate) fn compute_score( | ||
326 | ctx: &CompletionContext, | ||
327 | ty: &Type, | ||
328 | name: &str, | ||
329 | ) -> Option<CompletionScore> { | ||
330 | let (active_name, active_type) = if let Some(record_field) = &ctx.record_field_syntax { | ||
331 | mark::hit!(record_field_type_match); | ||
332 | let (struct_field, _local) = ctx.sema.resolve_record_field(record_field)?; | ||
333 | (struct_field.name(ctx.db).to_string(), struct_field.signature_ty(ctx.db)) | ||
334 | } else if let Some(active_parameter) = &ctx.active_parameter { | ||
335 | mark::hit!(active_param_type_match); | ||
336 | (active_parameter.name.clone(), active_parameter.ty.clone()) | ||
337 | } else { | ||
338 | return None; | ||
339 | }; | ||
340 | |||
341 | // Compute score | ||
342 | // For the same type | ||
343 | if &active_type != ty { | ||
344 | return None; | ||
345 | } | ||
346 | |||
347 | let mut res = CompletionScore::TypeMatch; | ||
348 | |||
349 | // If same type + same name then go top position | ||
350 | if active_name == name { | ||
351 | res = CompletionScore::TypeAndNameMatch | ||
352 | } | ||
353 | |||
354 | Some(res) | ||
355 | } | ||
356 | |||
357 | enum Params { | ||
358 | Named(Vec<String>), | ||
359 | Anonymous(usize), | ||
360 | } | ||
361 | |||
362 | impl Params { | ||
363 | fn len(&self) -> usize { | ||
364 | match self { | ||
365 | Params::Named(xs) => xs.len(), | ||
366 | Params::Anonymous(len) => *len, | ||
367 | } | ||
368 | } | ||
369 | |||
370 | fn is_empty(&self) -> bool { | ||
371 | self.len() == 0 | ||
372 | } | ||
373 | } | ||
374 | |||
375 | impl Builder { | ||
376 | fn add_call_parens(mut self, ctx: &CompletionContext, name: String, params: Params) -> Builder { | ||
377 | if !ctx.config.add_call_parenthesis { | ||
378 | return self; | ||
379 | } | ||
380 | if ctx.use_item_syntax.is_some() { | ||
381 | mark::hit!(no_parens_in_use_item); | ||
382 | return self; | ||
383 | } | ||
384 | if ctx.is_pattern_call { | ||
385 | mark::hit!(dont_duplicate_pattern_parens); | ||
386 | return self; | ||
387 | } | ||
388 | if ctx.is_call { | ||
389 | return self; | ||
390 | } | ||
391 | |||
392 | // Don't add parentheses if the expected type is some function reference. | ||
393 | if let Some(ty) = &ctx.expected_type { | ||
394 | if ty.is_fn() { | ||
395 | mark::hit!(no_call_parens_if_fn_ptr_needed); | ||
396 | return self; | ||
397 | } | ||
398 | } | ||
399 | |||
400 | let cap = match ctx.config.snippet_cap { | ||
401 | Some(it) => it, | ||
402 | None => return self, | ||
403 | }; | ||
404 | // If not an import, add parenthesis automatically. | ||
405 | mark::hit!(inserts_parens_for_function_calls); | ||
406 | |||
407 | let (snippet, label) = if params.is_empty() { | ||
408 | (format!("{}()$0", name), format!("{}()", name)) | ||
409 | } else { | ||
410 | self = self.trigger_call_info(); | ||
411 | let snippet = match (ctx.config.add_call_argument_snippets, params) { | ||
412 | (true, Params::Named(params)) => { | ||
413 | let function_params_snippet = | ||
414 | params.iter().enumerate().format_with(", ", |(index, param_name), f| { | ||
415 | f(&format_args!("${{{}:{}}}", index + 1, param_name)) | ||
416 | }); | ||
417 | format!("{}({})$0", name, function_params_snippet) | ||
418 | } | ||
419 | _ => { | ||
420 | mark::hit!(suppress_arg_snippets); | ||
421 | format!("{}($0)", name) | ||
422 | } | ||
423 | }; | ||
424 | |||
425 | (snippet, format!("{}(…)", name)) | ||
426 | }; | ||
427 | self.lookup_by(name).label(label).insert_snippet(cap, snippet) | ||
428 | } | ||
429 | } | ||
430 | |||
431 | fn is_deprecated(node: impl HasAttrs, db: &RootDatabase) -> bool { | ||
432 | node.attrs(db).by_key("deprecated").exists() | ||
433 | } | ||
434 | |||
435 | fn guess_macro_braces(macro_name: &str, docs: &str) -> (&'static str, &'static str) { | ||
436 | let mut votes = [0, 0, 0]; | ||
437 | for (idx, s) in docs.match_indices(¯o_name) { | ||
438 | let (before, after) = (&docs[..idx], &docs[idx + s.len()..]); | ||
439 | // Ensure to match the full word | ||
440 | if after.starts_with('!') | ||
441 | && !before.ends_with(|c: char| c == '_' || c.is_ascii_alphanumeric()) | ||
442 | { | ||
443 | // It may have spaces before the braces like `foo! {}` | ||
444 | match after[1..].chars().find(|&c| !c.is_whitespace()) { | ||
445 | Some('{') => votes[0] += 1, | ||
446 | Some('[') => votes[1] += 1, | ||
447 | Some('(') => votes[2] += 1, | ||
448 | _ => {} | ||
449 | } | ||
450 | } | ||
451 | } | ||
452 | |||
453 | // Insert a space before `{}`. | ||
454 | // We prefer the last one when some votes equal. | ||
455 | let (_vote, (bra, ket)) = votes | ||
456 | .iter() | ||
457 | .zip(&[(" {", "}"), ("[", "]"), ("(", ")")]) | ||
458 | .max_by_key(|&(&vote, _)| vote) | ||
459 | .unwrap(); | ||
460 | (*bra, *ket) | ||
461 | } | ||
462 | |||
463 | #[cfg(test)] | ||
464 | mod tests { | ||
465 | use std::cmp::Reverse; | ||
466 | |||
467 | use expect_test::{expect, Expect}; | ||
468 | use test_utils::mark; | ||
469 | |||
470 | use crate::{ | ||
471 | completion::{ | ||
472 | test_utils::{ | ||
473 | check_edit, check_edit_with_config, do_completion, get_all_completion_items, | ||
474 | }, | ||
475 | CompletionConfig, CompletionKind, | ||
476 | }, | ||
477 | CompletionScore, | ||
478 | }; | ||
479 | |||
480 | fn check(ra_fixture: &str, expect: Expect) { | ||
481 | let actual = do_completion(ra_fixture, CompletionKind::Reference); | ||
482 | expect.assert_debug_eq(&actual); | ||
483 | } | ||
484 | |||
485 | fn check_scores(ra_fixture: &str, expect: Expect) { | ||
486 | fn display_score(score: Option<CompletionScore>) -> &'static str { | ||
487 | match score { | ||
488 | Some(CompletionScore::TypeMatch) => "[type]", | ||
489 | Some(CompletionScore::TypeAndNameMatch) => "[type+name]", | ||
490 | None => "[]".into(), | ||
491 | } | ||
492 | } | ||
493 | |||
494 | let mut completions = get_all_completion_items(CompletionConfig::default(), ra_fixture); | ||
495 | completions.sort_by_key(|it| (Reverse(it.score()), it.label().to_string())); | ||
496 | let actual = completions | ||
497 | .into_iter() | ||
498 | .filter(|it| it.completion_kind == CompletionKind::Reference) | ||
499 | .map(|it| { | ||
500 | let tag = it.kind().unwrap().tag(); | ||
501 | let score = display_score(it.score()); | ||
502 | format!("{} {} {}\n", tag, it.label(), score) | ||
503 | }) | ||
504 | .collect::<String>(); | ||
505 | expect.assert_eq(&actual); | ||
506 | } | ||
507 | |||
508 | #[test] | ||
509 | fn enum_detail_includes_record_fields() { | ||
510 | check( | ||
511 | r#" | ||
512 | enum Foo { Foo { x: i32, y: i32 } } | ||
513 | |||
514 | fn main() { Foo::Fo<|> } | ||
515 | "#, | ||
516 | expect![[r#" | ||
517 | [ | ||
518 | CompletionItem { | ||
519 | label: "Foo", | ||
520 | source_range: 54..56, | ||
521 | delete: 54..56, | ||
522 | insert: "Foo", | ||
523 | kind: EnumVariant, | ||
524 | detail: "{ x: i32, y: i32 }", | ||
525 | }, | ||
526 | ] | ||
527 | "#]], | ||
528 | ); | ||
529 | } | ||
530 | |||
531 | #[test] | ||
532 | fn enum_detail_doesnt_include_tuple_fields() { | ||
533 | check( | ||
534 | r#" | ||
535 | enum Foo { Foo (i32, i32) } | ||
536 | |||
537 | fn main() { Foo::Fo<|> } | ||
538 | "#, | ||
539 | expect![[r#" | ||
540 | [ | ||
541 | CompletionItem { | ||
542 | label: "Foo(…)", | ||
543 | source_range: 46..48, | ||
544 | delete: 46..48, | ||
545 | insert: "Foo($0)", | ||
546 | kind: EnumVariant, | ||
547 | lookup: "Foo", | ||
548 | detail: "(i32, i32)", | ||
549 | trigger_call_info: true, | ||
550 | }, | ||
551 | ] | ||
552 | "#]], | ||
553 | ); | ||
554 | } | ||
555 | |||
556 | #[test] | ||
557 | fn enum_detail_just_parentheses_for_unit() { | ||
558 | check( | ||
559 | r#" | ||
560 | enum Foo { Foo } | ||
561 | |||
562 | fn main() { Foo::Fo<|> } | ||
563 | "#, | ||
564 | expect![[r#" | ||
565 | [ | ||
566 | CompletionItem { | ||
567 | label: "Foo", | ||
568 | source_range: 35..37, | ||
569 | delete: 35..37, | ||
570 | insert: "Foo", | ||
571 | kind: EnumVariant, | ||
572 | detail: "()", | ||
573 | }, | ||
574 | ] | ||
575 | "#]], | ||
576 | ); | ||
577 | } | ||
578 | |||
579 | #[test] | ||
580 | fn sets_deprecated_flag_in_completion_items() { | ||
581 | check( | ||
582 | r#" | ||
583 | #[deprecated] | ||
584 | fn something_deprecated() {} | ||
585 | #[deprecated(since = "1.0.0")] | ||
586 | fn something_else_deprecated() {} | ||
587 | |||
588 | fn main() { som<|> } | ||
589 | "#, | ||
590 | expect![[r#" | ||
591 | [ | ||
592 | CompletionItem { | ||
593 | label: "main()", | ||
594 | source_range: 121..124, | ||
595 | delete: 121..124, | ||
596 | insert: "main()$0", | ||
597 | kind: Function, | ||
598 | lookup: "main", | ||
599 | detail: "fn main()", | ||
600 | }, | ||
601 | CompletionItem { | ||
602 | label: "something_deprecated()", | ||
603 | source_range: 121..124, | ||
604 | delete: 121..124, | ||
605 | insert: "something_deprecated()$0", | ||
606 | kind: Function, | ||
607 | lookup: "something_deprecated", | ||
608 | detail: "fn something_deprecated()", | ||
609 | deprecated: true, | ||
610 | }, | ||
611 | CompletionItem { | ||
612 | label: "something_else_deprecated()", | ||
613 | source_range: 121..124, | ||
614 | delete: 121..124, | ||
615 | insert: "something_else_deprecated()$0", | ||
616 | kind: Function, | ||
617 | lookup: "something_else_deprecated", | ||
618 | detail: "fn something_else_deprecated()", | ||
619 | deprecated: true, | ||
620 | }, | ||
621 | ] | ||
622 | "#]], | ||
623 | ); | ||
624 | |||
625 | check( | ||
626 | r#" | ||
627 | struct A { #[deprecated] the_field: u32 } | ||
628 | fn foo() { A { the<|> } } | ||
629 | "#, | ||
630 | expect![[r#" | ||
631 | [ | ||
632 | CompletionItem { | ||
633 | label: "the_field", | ||
634 | source_range: 57..60, | ||
635 | delete: 57..60, | ||
636 | insert: "the_field", | ||
637 | kind: Field, | ||
638 | detail: "u32", | ||
639 | deprecated: true, | ||
640 | }, | ||
641 | ] | ||
642 | "#]], | ||
643 | ); | ||
644 | } | ||
645 | |||
646 | #[test] | ||
647 | fn renders_docs() { | ||
648 | check( | ||
649 | r#" | ||
650 | struct S { | ||
651 | /// Field docs | ||
652 | foo: | ||
653 | } | ||
654 | impl S { | ||
655 | /// Method docs | ||
656 | fn bar(self) { self.<|> } | ||
657 | }"#, | ||
658 | expect![[r#" | ||
659 | [ | ||
660 | CompletionItem { | ||
661 | label: "bar()", | ||
662 | source_range: 94..94, | ||
663 | delete: 94..94, | ||
664 | insert: "bar()$0", | ||
665 | kind: Method, | ||
666 | lookup: "bar", | ||
667 | detail: "fn bar(self)", | ||
668 | documentation: Documentation( | ||
669 | "Method docs", | ||
670 | ), | ||
671 | }, | ||
672 | CompletionItem { | ||
673 | label: "foo", | ||
674 | source_range: 94..94, | ||
675 | delete: 94..94, | ||
676 | insert: "foo", | ||
677 | kind: Field, | ||
678 | detail: "{unknown}", | ||
679 | documentation: Documentation( | ||
680 | "Field docs", | ||
681 | ), | ||
682 | }, | ||
683 | ] | ||
684 | "#]], | ||
685 | ); | ||
686 | |||
687 | check( | ||
688 | r#" | ||
689 | use self::my<|>; | ||
690 | |||
691 | /// mod docs | ||
692 | mod my { } | ||
693 | |||
694 | /// enum docs | ||
695 | enum E { | ||
696 | /// variant docs | ||
697 | V | ||
698 | } | ||
699 | use self::E::*; | ||
700 | "#, | ||
701 | expect![[r#" | ||
702 | [ | ||
703 | CompletionItem { | ||
704 | label: "E", | ||
705 | source_range: 10..12, | ||
706 | delete: 10..12, | ||
707 | insert: "E", | ||
708 | kind: Enum, | ||
709 | documentation: Documentation( | ||
710 | "enum docs", | ||
711 | ), | ||
712 | }, | ||
713 | CompletionItem { | ||
714 | label: "V", | ||
715 | source_range: 10..12, | ||
716 | delete: 10..12, | ||
717 | insert: "V", | ||
718 | kind: EnumVariant, | ||
719 | detail: "()", | ||
720 | documentation: Documentation( | ||
721 | "variant docs", | ||
722 | ), | ||
723 | }, | ||
724 | CompletionItem { | ||
725 | label: "my", | ||
726 | source_range: 10..12, | ||
727 | delete: 10..12, | ||
728 | insert: "my", | ||
729 | kind: Module, | ||
730 | documentation: Documentation( | ||
731 | "mod docs", | ||
732 | ), | ||
733 | }, | ||
734 | ] | ||
735 | "#]], | ||
736 | ) | ||
737 | } | ||
738 | |||
739 | #[test] | ||
740 | fn dont_render_attrs() { | ||
741 | check( | ||
742 | r#" | ||
743 | struct S; | ||
744 | impl S { | ||
745 | #[inline] | ||
746 | fn the_method(&self) { } | ||
747 | } | ||
748 | fn foo(s: S) { s.<|> } | ||
749 | "#, | ||
750 | expect![[r#" | ||
751 | [ | ||
752 | CompletionItem { | ||
753 | label: "the_method()", | ||
754 | source_range: 81..81, | ||
755 | delete: 81..81, | ||
756 | insert: "the_method()$0", | ||
757 | kind: Method, | ||
758 | lookup: "the_method", | ||
759 | detail: "fn the_method(&self)", | ||
760 | }, | ||
761 | ] | ||
762 | "#]], | ||
763 | ) | ||
764 | } | ||
765 | |||
766 | #[test] | ||
767 | fn inserts_parens_for_function_calls() { | ||
768 | mark::check!(inserts_parens_for_function_calls); | ||
769 | check_edit( | ||
770 | "no_args", | ||
771 | r#" | ||
772 | fn no_args() {} | ||
773 | fn main() { no_<|> } | ||
774 | "#, | ||
775 | r#" | ||
776 | fn no_args() {} | ||
777 | fn main() { no_args()$0 } | ||
778 | "#, | ||
779 | ); | ||
780 | |||
781 | check_edit( | ||
782 | "with_args", | ||
783 | r#" | ||
784 | fn with_args(x: i32, y: String) {} | ||
785 | fn main() { with_<|> } | ||
786 | "#, | ||
787 | r#" | ||
788 | fn with_args(x: i32, y: String) {} | ||
789 | fn main() { with_args(${1:x}, ${2:y})$0 } | ||
790 | "#, | ||
791 | ); | ||
792 | |||
793 | check_edit( | ||
794 | "foo", | ||
795 | r#" | ||
796 | struct S; | ||
797 | impl S { | ||
798 | fn foo(&self) {} | ||
799 | } | ||
800 | fn bar(s: &S) { s.f<|> } | ||
801 | "#, | ||
802 | r#" | ||
803 | struct S; | ||
804 | impl S { | ||
805 | fn foo(&self) {} | ||
806 | } | ||
807 | fn bar(s: &S) { s.foo()$0 } | ||
808 | "#, | ||
809 | ); | ||
810 | |||
811 | check_edit( | ||
812 | "foo", | ||
813 | r#" | ||
814 | struct S {} | ||
815 | impl S { | ||
816 | fn foo(&self, x: i32) {} | ||
817 | } | ||
818 | fn bar(s: &S) { | ||
819 | s.f<|> | ||
820 | } | ||
821 | "#, | ||
822 | r#" | ||
823 | struct S {} | ||
824 | impl S { | ||
825 | fn foo(&self, x: i32) {} | ||
826 | } | ||
827 | fn bar(s: &S) { | ||
828 | s.foo(${1:x})$0 | ||
829 | } | ||
830 | "#, | ||
831 | ); | ||
832 | } | ||
833 | |||
834 | #[test] | ||
835 | fn suppress_arg_snippets() { | ||
836 | mark::check!(suppress_arg_snippets); | ||
837 | check_edit_with_config( | ||
838 | CompletionConfig { add_call_argument_snippets: false, ..CompletionConfig::default() }, | ||
839 | "with_args", | ||
840 | r#" | ||
841 | fn with_args(x: i32, y: String) {} | ||
842 | fn main() { with_<|> } | ||
843 | "#, | ||
844 | r#" | ||
845 | fn with_args(x: i32, y: String) {} | ||
846 | fn main() { with_args($0) } | ||
847 | "#, | ||
848 | ); | ||
849 | } | ||
850 | |||
851 | #[test] | ||
852 | fn strips_underscores_from_args() { | ||
853 | check_edit( | ||
854 | "foo", | ||
855 | r#" | ||
856 | fn foo(_foo: i32, ___bar: bool, ho_ge_: String) {} | ||
857 | fn main() { f<|> } | ||
858 | "#, | ||
859 | r#" | ||
860 | fn foo(_foo: i32, ___bar: bool, ho_ge_: String) {} | ||
861 | fn main() { foo(${1:foo}, ${2:bar}, ${3:ho_ge_})$0 } | ||
862 | "#, | ||
863 | ); | ||
864 | } | ||
865 | |||
866 | #[test] | ||
867 | fn inserts_parens_for_tuple_enums() { | ||
868 | mark::check!(inserts_parens_for_tuple_enums); | ||
869 | check_edit( | ||
870 | "Some", | ||
871 | r#" | ||
872 | enum Option<T> { Some(T), None } | ||
873 | use Option::*; | ||
874 | fn main() -> Option<i32> { | ||
875 | Som<|> | ||
876 | } | ||
877 | "#, | ||
878 | r#" | ||
879 | enum Option<T> { Some(T), None } | ||
880 | use Option::*; | ||
881 | fn main() -> Option<i32> { | ||
882 | Some($0) | ||
883 | } | ||
884 | "#, | ||
885 | ); | ||
886 | check_edit( | ||
887 | "Some", | ||
888 | r#" | ||
889 | enum Option<T> { Some(T), None } | ||
890 | use Option::*; | ||
891 | fn main(value: Option<i32>) { | ||
892 | match value { | ||
893 | Som<|> | ||
894 | } | ||
895 | } | ||
896 | "#, | ||
897 | r#" | ||
898 | enum Option<T> { Some(T), None } | ||
899 | use Option::*; | ||
900 | fn main(value: Option<i32>) { | ||
901 | match value { | ||
902 | Some($0) | ||
903 | } | ||
904 | } | ||
905 | "#, | ||
906 | ); | ||
907 | } | ||
908 | |||
909 | #[test] | ||
910 | fn dont_duplicate_pattern_parens() { | ||
911 | mark::check!(dont_duplicate_pattern_parens); | ||
912 | check_edit( | ||
913 | "Var", | ||
914 | r#" | ||
915 | enum E { Var(i32) } | ||
916 | fn main() { | ||
917 | match E::Var(92) { | ||
918 | E::<|>(92) => (), | ||
919 | } | ||
920 | } | ||
921 | "#, | ||
922 | r#" | ||
923 | enum E { Var(i32) } | ||
924 | fn main() { | ||
925 | match E::Var(92) { | ||
926 | E::Var(92) => (), | ||
927 | } | ||
928 | } | ||
929 | "#, | ||
930 | ); | ||
931 | } | ||
932 | |||
933 | #[test] | ||
934 | fn no_call_parens_if_fn_ptr_needed() { | ||
935 | mark::check!(no_call_parens_if_fn_ptr_needed); | ||
936 | check_edit( | ||
937 | "foo", | ||
938 | r#" | ||
939 | fn foo(foo: u8, bar: u8) {} | ||
940 | struct ManualVtable { f: fn(u8, u8) } | ||
941 | |||
942 | fn main() -> ManualVtable { | ||
943 | ManualVtable { f: f<|> } | ||
944 | } | ||
945 | "#, | ||
946 | r#" | ||
947 | fn foo(foo: u8, bar: u8) {} | ||
948 | struct ManualVtable { f: fn(u8, u8) } | ||
949 | |||
950 | fn main() -> ManualVtable { | ||
951 | ManualVtable { f: foo } | ||
952 | } | ||
953 | "#, | ||
954 | ); | ||
955 | } | ||
956 | |||
957 | #[test] | ||
958 | fn no_parens_in_use_item() { | ||
959 | mark::check!(no_parens_in_use_item); | ||
960 | check_edit( | ||
961 | "foo", | ||
962 | r#" | ||
963 | mod m { pub fn foo() {} } | ||
964 | use crate::m::f<|>; | ||
965 | "#, | ||
966 | r#" | ||
967 | mod m { pub fn foo() {} } | ||
968 | use crate::m::foo; | ||
969 | "#, | ||
970 | ); | ||
971 | } | ||
972 | |||
973 | #[test] | ||
974 | fn no_parens_in_call() { | ||
975 | check_edit( | ||
976 | "foo", | ||
977 | r#" | ||
978 | fn foo(x: i32) {} | ||
979 | fn main() { f<|>(); } | ||
980 | "#, | ||
981 | r#" | ||
982 | fn foo(x: i32) {} | ||
983 | fn main() { foo(); } | ||
984 | "#, | ||
985 | ); | ||
986 | check_edit( | ||
987 | "foo", | ||
988 | r#" | ||
989 | struct Foo; | ||
990 | impl Foo { fn foo(&self){} } | ||
991 | fn f(foo: &Foo) { foo.f<|>(); } | ||
992 | "#, | ||
993 | r#" | ||
994 | struct Foo; | ||
995 | impl Foo { fn foo(&self){} } | ||
996 | fn f(foo: &Foo) { foo.foo(); } | ||
997 | "#, | ||
998 | ); | ||
999 | } | ||
1000 | |||
1001 | #[test] | ||
1002 | fn inserts_angle_brackets_for_generics() { | ||
1003 | mark::check!(inserts_angle_brackets_for_generics); | ||
1004 | check_edit( | ||
1005 | "Vec", | ||
1006 | r#" | ||
1007 | struct Vec<T> {} | ||
1008 | fn foo(xs: Ve<|>) | ||
1009 | "#, | ||
1010 | r#" | ||
1011 | struct Vec<T> {} | ||
1012 | fn foo(xs: Vec<$0>) | ||
1013 | "#, | ||
1014 | ); | ||
1015 | check_edit( | ||
1016 | "Vec", | ||
1017 | r#" | ||
1018 | type Vec<T> = (T,); | ||
1019 | fn foo(xs: Ve<|>) | ||
1020 | "#, | ||
1021 | r#" | ||
1022 | type Vec<T> = (T,); | ||
1023 | fn foo(xs: Vec<$0>) | ||
1024 | "#, | ||
1025 | ); | ||
1026 | check_edit( | ||
1027 | "Vec", | ||
1028 | r#" | ||
1029 | struct Vec<T = i128> {} | ||
1030 | fn foo(xs: Ve<|>) | ||
1031 | "#, | ||
1032 | r#" | ||
1033 | struct Vec<T = i128> {} | ||
1034 | fn foo(xs: Vec) | ||
1035 | "#, | ||
1036 | ); | ||
1037 | check_edit( | ||
1038 | "Vec", | ||
1039 | r#" | ||
1040 | struct Vec<T> {} | ||
1041 | fn foo(xs: Ve<|><i128>) | ||
1042 | "#, | ||
1043 | r#" | ||
1044 | struct Vec<T> {} | ||
1045 | fn foo(xs: Vec<i128>) | ||
1046 | "#, | ||
1047 | ); | ||
1048 | } | ||
1049 | |||
1050 | #[test] | ||
1051 | fn dont_insert_macro_call_parens_unncessary() { | ||
1052 | mark::check!(dont_insert_macro_call_parens_unncessary); | ||
1053 | check_edit( | ||
1054 | "frobnicate!", | ||
1055 | r#" | ||
1056 | //- /main.rs | ||
1057 | use foo::<|>; | ||
1058 | //- /foo/lib.rs | ||
1059 | #[macro_export] | ||
1060 | macro_rules frobnicate { () => () } | ||
1061 | "#, | ||
1062 | r#" | ||
1063 | use foo::frobnicate; | ||
1064 | "#, | ||
1065 | ); | ||
1066 | |||
1067 | check_edit( | ||
1068 | "frobnicate!", | ||
1069 | r#" | ||
1070 | macro_rules frobnicate { () => () } | ||
1071 | fn main() { frob<|>!(); } | ||
1072 | "#, | ||
1073 | r#" | ||
1074 | macro_rules frobnicate { () => () } | ||
1075 | fn main() { frobnicate!(); } | ||
1076 | "#, | ||
1077 | ); | ||
1078 | } | ||
1079 | |||
1080 | #[test] | ||
1081 | fn active_param_score() { | ||
1082 | mark::check!(active_param_type_match); | ||
1083 | check_scores( | ||
1084 | r#" | ||
1085 | struct S { foo: i64, bar: u32, baz: u32 } | ||
1086 | fn test(bar: u32) { } | ||
1087 | fn foo(s: S) { test(s.<|>) } | ||
1088 | "#, | ||
1089 | expect![[r#" | ||
1090 | fd bar [type+name] | ||
1091 | fd baz [type] | ||
1092 | fd foo [] | ||
1093 | "#]], | ||
1094 | ); | ||
1095 | } | ||
1096 | |||
1097 | #[test] | ||
1098 | fn record_field_scores() { | ||
1099 | mark::check!(record_field_type_match); | ||
1100 | check_scores( | ||
1101 | r#" | ||
1102 | struct A { foo: i64, bar: u32, baz: u32 } | ||
1103 | struct B { x: (), y: f32, bar: u32 } | ||
1104 | fn foo(a: A) { B { bar: a.<|> }; } | ||
1105 | "#, | ||
1106 | expect![[r#" | ||
1107 | fd bar [type+name] | ||
1108 | fd baz [type] | ||
1109 | fd foo [] | ||
1110 | "#]], | ||
1111 | ) | ||
1112 | } | ||
1113 | |||
1114 | #[test] | ||
1115 | fn record_field_and_call_scores() { | ||
1116 | check_scores( | ||
1117 | r#" | ||
1118 | struct A { foo: i64, bar: u32, baz: u32 } | ||
1119 | struct B { x: (), y: f32, bar: u32 } | ||
1120 | fn f(foo: i64) { } | ||
1121 | fn foo(a: A) { B { bar: f(a.<|>) }; } | ||
1122 | "#, | ||
1123 | expect![[r#" | ||
1124 | fd foo [type+name] | ||
1125 | fd bar [] | ||
1126 | fd baz [] | ||
1127 | "#]], | ||
1128 | ); | ||
1129 | check_scores( | ||
1130 | r#" | ||
1131 | struct A { foo: i64, bar: u32, baz: u32 } | ||
1132 | struct B { x: (), y: f32, bar: u32 } | ||
1133 | fn f(foo: i64) { } | ||
1134 | fn foo(a: A) { f(B { bar: a.<|> }); } | ||
1135 | "#, | ||
1136 | expect![[r#" | ||
1137 | fd bar [type+name] | ||
1138 | fd baz [type] | ||
1139 | fd foo [] | ||
1140 | "#]], | ||
1141 | ); | ||
1142 | } | ||
1143 | |||
1144 | #[test] | ||
1145 | fn prioritize_exact_ref_match() { | ||
1146 | check_scores( | ||
1147 | r#" | ||
1148 | struct WorldSnapshot { _f: () }; | ||
1149 | fn go(world: &WorldSnapshot) { go(w<|>) } | ||
1150 | "#, | ||
1151 | expect![[r#" | ||
1152 | bn world [type+name] | ||
1153 | st WorldSnapshot [] | ||
1154 | fn go(…) [] | ||
1155 | "#]], | ||
1156 | ); | ||
1157 | } | ||
1158 | |||
1159 | #[test] | ||
1160 | fn too_many_arguments() { | ||
1161 | mark::check!(too_many_arguments); | ||
1162 | check_scores( | ||
1163 | r#" | ||
1164 | struct Foo; | ||
1165 | fn f(foo: &Foo) { f(foo, w<|>) } | ||
1166 | "#, | ||
1167 | expect![[r#" | ||
1168 | st Foo [] | ||
1169 | fn f(…) [] | ||
1170 | bn foo [] | ||
1171 | "#]], | ||
1172 | ); | ||
1173 | } | ||
1174 | |||
1175 | #[test] | ||
1176 | fn guesses_macro_braces() { | ||
1177 | check_edit( | ||
1178 | "vec!", | ||
1179 | r#" | ||
1180 | /// Creates a [`Vec`] containing the arguments. | ||
1181 | /// | ||
1182 | /// ``` | ||
1183 | /// let v = vec![1, 2, 3]; | ||
1184 | /// assert_eq!(v[0], 1); | ||
1185 | /// assert_eq!(v[1], 2); | ||
1186 | /// assert_eq!(v[2], 3); | ||
1187 | /// ``` | ||
1188 | macro_rules! vec { () => {} } | ||
1189 | |||
1190 | fn fn main() { v<|> } | ||
1191 | "#, | ||
1192 | r#" | ||
1193 | /// Creates a [`Vec`] containing the arguments. | ||
1194 | /// | ||
1195 | /// ``` | ||
1196 | /// let v = vec![1, 2, 3]; | ||
1197 | /// assert_eq!(v[0], 1); | ||
1198 | /// assert_eq!(v[1], 2); | ||
1199 | /// assert_eq!(v[2], 3); | ||
1200 | /// ``` | ||
1201 | macro_rules! vec { () => {} } | ||
1202 | |||
1203 | fn fn main() { vec![$0] } | ||
1204 | "#, | ||
1205 | ); | ||
1206 | |||
1207 | check_edit( | ||
1208 | "foo!", | ||
1209 | r#" | ||
1210 | /// Foo | ||
1211 | /// | ||
1212 | /// Don't call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`, | ||
1213 | /// call as `let _=foo! { hello world };` | ||
1214 | macro_rules! foo { () => {} } | ||
1215 | fn main() { <|> } | ||
1216 | "#, | ||
1217 | r#" | ||
1218 | /// Foo | ||
1219 | /// | ||
1220 | /// Don't call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`, | ||
1221 | /// call as `let _=foo! { hello world };` | ||
1222 | macro_rules! foo { () => {} } | ||
1223 | fn main() { foo! {$0} } | ||
1224 | "#, | ||
1225 | ) | ||
1226 | } | ||
1227 | } | ||