diff options
author | Igor Aleksanov <[email protected]> | 2020-08-14 05:34:07 +0100 |
---|---|---|
committer | Igor Aleksanov <[email protected]> | 2020-08-14 05:34:07 +0100 |
commit | c26c911ec1e6c2ad1dcb7d155a6a1d528839ad1a (patch) | |
tree | 7cff36c38234be0afb65273146d8247083a5cfeb /crates/ide/src/call_info.rs | |
parent | 3c018bf84de5c693b5ee1c6bec0fed3b201c2060 (diff) | |
parent | f1f73649a686dc6e6449afc35e0fa6fed00e225d (diff) |
Merge branch 'master' into add-disable-diagnostics
Diffstat (limited to 'crates/ide/src/call_info.rs')
-rw-r--r-- | crates/ide/src/call_info.rs | 742 |
1 files changed, 742 insertions, 0 deletions
diff --git a/crates/ide/src/call_info.rs b/crates/ide/src/call_info.rs new file mode 100644 index 000000000..86abd2d8c --- /dev/null +++ b/crates/ide/src/call_info.rs | |||
@@ -0,0 +1,742 @@ | |||
1 | //! FIXME: write short doc here | ||
2 | use either::Either; | ||
3 | use hir::{Docs, HirDisplay, Semantics, Type}; | ||
4 | use ide_db::RootDatabase; | ||
5 | use stdx::format_to; | ||
6 | use syntax::{ | ||
7 | ast::{self, ArgListOwner}, | ||
8 | match_ast, AstNode, SyntaxNode, SyntaxToken, TextRange, TextSize, | ||
9 | }; | ||
10 | use test_utils::mark; | ||
11 | |||
12 | use crate::FilePosition; | ||
13 | |||
14 | /// Contains information about a call site. Specifically the | ||
15 | /// `FunctionSignature`and current parameter. | ||
16 | #[derive(Debug)] | ||
17 | pub struct CallInfo { | ||
18 | pub doc: Option<String>, | ||
19 | pub signature: String, | ||
20 | pub active_parameter: Option<usize>, | ||
21 | parameters: Vec<TextRange>, | ||
22 | } | ||
23 | |||
24 | impl CallInfo { | ||
25 | pub fn parameter_labels(&self) -> impl Iterator<Item = &str> + '_ { | ||
26 | self.parameters.iter().map(move |&it| &self.signature[it]) | ||
27 | } | ||
28 | pub fn parameter_ranges(&self) -> &[TextRange] { | ||
29 | &self.parameters | ||
30 | } | ||
31 | fn push_param(&mut self, param: &str) { | ||
32 | if !self.signature.ends_with('(') { | ||
33 | self.signature.push_str(", "); | ||
34 | } | ||
35 | let start = TextSize::of(&self.signature); | ||
36 | self.signature.push_str(param); | ||
37 | let end = TextSize::of(&self.signature); | ||
38 | self.parameters.push(TextRange::new(start, end)) | ||
39 | } | ||
40 | } | ||
41 | |||
42 | /// Computes parameter information for the given call expression. | ||
43 | pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<CallInfo> { | ||
44 | let sema = Semantics::new(db); | ||
45 | let file = sema.parse(position.file_id); | ||
46 | let file = file.syntax(); | ||
47 | let token = file.token_at_offset(position.offset).next()?; | ||
48 | let token = sema.descend_into_macros(token); | ||
49 | |||
50 | let (callable, active_parameter) = call_info_impl(&sema, token)?; | ||
51 | |||
52 | let mut res = | ||
53 | CallInfo { doc: None, signature: String::new(), parameters: vec![], active_parameter }; | ||
54 | |||
55 | match callable.kind() { | ||
56 | hir::CallableKind::Function(func) => { | ||
57 | res.doc = func.docs(db).map(|it| it.as_str().to_string()); | ||
58 | format_to!(res.signature, "fn {}", func.name(db)); | ||
59 | } | ||
60 | hir::CallableKind::TupleStruct(strukt) => { | ||
61 | res.doc = strukt.docs(db).map(|it| it.as_str().to_string()); | ||
62 | format_to!(res.signature, "struct {}", strukt.name(db)); | ||
63 | } | ||
64 | hir::CallableKind::TupleEnumVariant(variant) => { | ||
65 | res.doc = variant.docs(db).map(|it| it.as_str().to_string()); | ||
66 | format_to!( | ||
67 | res.signature, | ||
68 | "enum {}::{}", | ||
69 | variant.parent_enum(db).name(db), | ||
70 | variant.name(db) | ||
71 | ); | ||
72 | } | ||
73 | hir::CallableKind::Closure => (), | ||
74 | } | ||
75 | |||
76 | res.signature.push('('); | ||
77 | { | ||
78 | if let Some(self_param) = callable.receiver_param(db) { | ||
79 | format_to!(res.signature, "{}", self_param) | ||
80 | } | ||
81 | let mut buf = String::new(); | ||
82 | for (pat, ty) in callable.params(db) { | ||
83 | buf.clear(); | ||
84 | if let Some(pat) = pat { | ||
85 | match pat { | ||
86 | Either::Left(_self) => format_to!(buf, "self: "), | ||
87 | Either::Right(pat) => format_to!(buf, "{}: ", pat), | ||
88 | } | ||
89 | } | ||
90 | format_to!(buf, "{}", ty.display(db)); | ||
91 | res.push_param(&buf); | ||
92 | } | ||
93 | } | ||
94 | res.signature.push(')'); | ||
95 | |||
96 | match callable.kind() { | ||
97 | hir::CallableKind::Function(_) | hir::CallableKind::Closure => { | ||
98 | let ret_type = callable.return_type(); | ||
99 | if !ret_type.is_unit() { | ||
100 | format_to!(res.signature, " -> {}", ret_type.display(db)); | ||
101 | } | ||
102 | } | ||
103 | hir::CallableKind::TupleStruct(_) | hir::CallableKind::TupleEnumVariant(_) => {} | ||
104 | } | ||
105 | Some(res) | ||
106 | } | ||
107 | |||
108 | fn call_info_impl( | ||
109 | sema: &Semantics<RootDatabase>, | ||
110 | token: SyntaxToken, | ||
111 | ) -> Option<(hir::Callable, Option<usize>)> { | ||
112 | // Find the calling expression and it's NameRef | ||
113 | let calling_node = FnCallNode::with_node(&token.parent())?; | ||
114 | |||
115 | let callable = match &calling_node { | ||
116 | FnCallNode::CallExpr(call) => sema.type_of_expr(&call.expr()?)?.as_callable(sema.db)?, | ||
117 | FnCallNode::MethodCallExpr(call) => sema.resolve_method_call_as_callable(call)?, | ||
118 | }; | ||
119 | let active_param = if let Some(arg_list) = calling_node.arg_list() { | ||
120 | // Number of arguments specified at the call site | ||
121 | let num_args_at_callsite = arg_list.args().count(); | ||
122 | |||
123 | let arg_list_range = arg_list.syntax().text_range(); | ||
124 | if !arg_list_range.contains_inclusive(token.text_range().start()) { | ||
125 | mark::hit!(call_info_bad_offset); | ||
126 | return None; | ||
127 | } | ||
128 | let param = std::cmp::min( | ||
129 | num_args_at_callsite, | ||
130 | arg_list | ||
131 | .args() | ||
132 | .take_while(|arg| arg.syntax().text_range().end() <= token.text_range().start()) | ||
133 | .count(), | ||
134 | ); | ||
135 | |||
136 | Some(param) | ||
137 | } else { | ||
138 | None | ||
139 | }; | ||
140 | Some((callable, active_param)) | ||
141 | } | ||
142 | |||
143 | #[derive(Debug)] | ||
144 | pub(crate) struct ActiveParameter { | ||
145 | pub(crate) ty: Type, | ||
146 | pub(crate) name: String, | ||
147 | } | ||
148 | |||
149 | impl ActiveParameter { | ||
150 | pub(crate) fn at(db: &RootDatabase, position: FilePosition) -> Option<Self> { | ||
151 | let sema = Semantics::new(db); | ||
152 | let file = sema.parse(position.file_id); | ||
153 | let file = file.syntax(); | ||
154 | let token = file.token_at_offset(position.offset).next()?; | ||
155 | let token = sema.descend_into_macros(token); | ||
156 | Self::at_token(&sema, token) | ||
157 | } | ||
158 | |||
159 | pub(crate) fn at_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Option<Self> { | ||
160 | let (signature, active_parameter) = call_info_impl(&sema, token)?; | ||
161 | |||
162 | let idx = active_parameter?; | ||
163 | let mut params = signature.params(sema.db); | ||
164 | if !(idx < params.len()) { | ||
165 | mark::hit!(too_many_arguments); | ||
166 | return None; | ||
167 | } | ||
168 | let (pat, ty) = params.swap_remove(idx); | ||
169 | let name = pat?.to_string(); | ||
170 | Some(ActiveParameter { ty, name }) | ||
171 | } | ||
172 | } | ||
173 | |||
174 | #[derive(Debug)] | ||
175 | pub(crate) enum FnCallNode { | ||
176 | CallExpr(ast::CallExpr), | ||
177 | MethodCallExpr(ast::MethodCallExpr), | ||
178 | } | ||
179 | |||
180 | impl FnCallNode { | ||
181 | fn with_node(syntax: &SyntaxNode) -> Option<FnCallNode> { | ||
182 | syntax.ancestors().find_map(|node| { | ||
183 | match_ast! { | ||
184 | match node { | ||
185 | ast::CallExpr(it) => Some(FnCallNode::CallExpr(it)), | ||
186 | ast::MethodCallExpr(it) => { | ||
187 | let arg_list = it.arg_list()?; | ||
188 | if !arg_list.syntax().text_range().contains_range(syntax.text_range()) { | ||
189 | return None; | ||
190 | } | ||
191 | Some(FnCallNode::MethodCallExpr(it)) | ||
192 | }, | ||
193 | _ => None, | ||
194 | } | ||
195 | } | ||
196 | }) | ||
197 | } | ||
198 | |||
199 | pub(crate) fn with_node_exact(node: &SyntaxNode) -> Option<FnCallNode> { | ||
200 | match_ast! { | ||
201 | match node { | ||
202 | ast::CallExpr(it) => Some(FnCallNode::CallExpr(it)), | ||
203 | ast::MethodCallExpr(it) => Some(FnCallNode::MethodCallExpr(it)), | ||
204 | _ => None, | ||
205 | } | ||
206 | } | ||
207 | } | ||
208 | |||
209 | pub(crate) fn name_ref(&self) -> Option<ast::NameRef> { | ||
210 | match self { | ||
211 | FnCallNode::CallExpr(call_expr) => Some(match call_expr.expr()? { | ||
212 | ast::Expr::PathExpr(path_expr) => path_expr.path()?.segment()?.name_ref()?, | ||
213 | _ => return None, | ||
214 | }), | ||
215 | |||
216 | FnCallNode::MethodCallExpr(call_expr) => { | ||
217 | call_expr.syntax().children().filter_map(ast::NameRef::cast).next() | ||
218 | } | ||
219 | } | ||
220 | } | ||
221 | |||
222 | fn arg_list(&self) -> Option<ast::ArgList> { | ||
223 | match self { | ||
224 | FnCallNode::CallExpr(expr) => expr.arg_list(), | ||
225 | FnCallNode::MethodCallExpr(expr) => expr.arg_list(), | ||
226 | } | ||
227 | } | ||
228 | } | ||
229 | |||
230 | #[cfg(test)] | ||
231 | mod tests { | ||
232 | use expect::{expect, Expect}; | ||
233 | use test_utils::mark; | ||
234 | |||
235 | use crate::mock_analysis::analysis_and_position; | ||
236 | |||
237 | fn check(ra_fixture: &str, expect: Expect) { | ||
238 | let (analysis, position) = analysis_and_position(ra_fixture); | ||
239 | let call_info = analysis.call_info(position).unwrap(); | ||
240 | let actual = match call_info { | ||
241 | Some(call_info) => { | ||
242 | let docs = match &call_info.doc { | ||
243 | None => "".to_string(), | ||
244 | Some(docs) => format!("{}\n------\n", docs.as_str()), | ||
245 | }; | ||
246 | let params = call_info | ||
247 | .parameter_labels() | ||
248 | .enumerate() | ||
249 | .map(|(i, param)| { | ||
250 | if Some(i) == call_info.active_parameter { | ||
251 | format!("<{}>", param) | ||
252 | } else { | ||
253 | param.to_string() | ||
254 | } | ||
255 | }) | ||
256 | .collect::<Vec<_>>() | ||
257 | .join(", "); | ||
258 | format!("{}{}\n({})\n", docs, call_info.signature, params) | ||
259 | } | ||
260 | None => String::new(), | ||
261 | }; | ||
262 | expect.assert_eq(&actual); | ||
263 | } | ||
264 | |||
265 | #[test] | ||
266 | fn test_fn_signature_two_args() { | ||
267 | check( | ||
268 | r#" | ||
269 | fn foo(x: u32, y: u32) -> u32 {x + y} | ||
270 | fn bar() { foo(<|>3, ); } | ||
271 | "#, | ||
272 | expect![[r#" | ||
273 | fn foo(x: u32, y: u32) -> u32 | ||
274 | (<x: u32>, y: u32) | ||
275 | "#]], | ||
276 | ); | ||
277 | check( | ||
278 | r#" | ||
279 | fn foo(x: u32, y: u32) -> u32 {x + y} | ||
280 | fn bar() { foo(3<|>, ); } | ||
281 | "#, | ||
282 | expect![[r#" | ||
283 | fn foo(x: u32, y: u32) -> u32 | ||
284 | (<x: u32>, y: u32) | ||
285 | "#]], | ||
286 | ); | ||
287 | check( | ||
288 | r#" | ||
289 | fn foo(x: u32, y: u32) -> u32 {x + y} | ||
290 | fn bar() { foo(3,<|> ); } | ||
291 | "#, | ||
292 | expect![[r#" | ||
293 | fn foo(x: u32, y: u32) -> u32 | ||
294 | (x: u32, <y: u32>) | ||
295 | "#]], | ||
296 | ); | ||
297 | check( | ||
298 | r#" | ||
299 | fn foo(x: u32, y: u32) -> u32 {x + y} | ||
300 | fn bar() { foo(3, <|>); } | ||
301 | "#, | ||
302 | expect![[r#" | ||
303 | fn foo(x: u32, y: u32) -> u32 | ||
304 | (x: u32, <y: u32>) | ||
305 | "#]], | ||
306 | ); | ||
307 | } | ||
308 | |||
309 | #[test] | ||
310 | fn test_fn_signature_two_args_empty() { | ||
311 | check( | ||
312 | r#" | ||
313 | fn foo(x: u32, y: u32) -> u32 {x + y} | ||
314 | fn bar() { foo(<|>); } | ||
315 | "#, | ||
316 | expect![[r#" | ||
317 | fn foo(x: u32, y: u32) -> u32 | ||
318 | (<x: u32>, y: u32) | ||
319 | "#]], | ||
320 | ); | ||
321 | } | ||
322 | |||
323 | #[test] | ||
324 | fn test_fn_signature_two_args_first_generics() { | ||
325 | check( | ||
326 | r#" | ||
327 | fn foo<T, U: Copy + Display>(x: T, y: U) -> u32 | ||
328 | where T: Copy + Display, U: Debug | ||
329 | { x + y } | ||
330 | |||
331 | fn bar() { foo(<|>3, ); } | ||
332 | "#, | ||
333 | expect![[r#" | ||
334 | fn foo(x: i32, y: {unknown}) -> u32 | ||
335 | (<x: i32>, y: {unknown}) | ||
336 | "#]], | ||
337 | ); | ||
338 | } | ||
339 | |||
340 | #[test] | ||
341 | fn test_fn_signature_no_params() { | ||
342 | check( | ||
343 | r#" | ||
344 | fn foo<T>() -> T where T: Copy + Display {} | ||
345 | fn bar() { foo(<|>); } | ||
346 | "#, | ||
347 | expect![[r#" | ||
348 | fn foo() -> {unknown} | ||
349 | () | ||
350 | "#]], | ||
351 | ); | ||
352 | } | ||
353 | |||
354 | #[test] | ||
355 | fn test_fn_signature_for_impl() { | ||
356 | check( | ||
357 | r#" | ||
358 | struct F; | ||
359 | impl F { pub fn new() { } } | ||
360 | fn bar() { | ||
361 | let _ : F = F::new(<|>); | ||
362 | } | ||
363 | "#, | ||
364 | expect![[r#" | ||
365 | fn new() | ||
366 | () | ||
367 | "#]], | ||
368 | ); | ||
369 | } | ||
370 | |||
371 | #[test] | ||
372 | fn test_fn_signature_for_method_self() { | ||
373 | check( | ||
374 | r#" | ||
375 | struct S; | ||
376 | impl S { pub fn do_it(&self) {} } | ||
377 | |||
378 | fn bar() { | ||
379 | let s: S = S; | ||
380 | s.do_it(<|>); | ||
381 | } | ||
382 | "#, | ||
383 | expect![[r#" | ||
384 | fn do_it(&self) | ||
385 | () | ||
386 | "#]], | ||
387 | ); | ||
388 | } | ||
389 | |||
390 | #[test] | ||
391 | fn test_fn_signature_for_method_with_arg() { | ||
392 | check( | ||
393 | r#" | ||
394 | struct S; | ||
395 | impl S { | ||
396 | fn foo(&self, x: i32) {} | ||
397 | } | ||
398 | |||
399 | fn main() { S.foo(<|>); } | ||
400 | "#, | ||
401 | expect![[r#" | ||
402 | fn foo(&self, x: i32) | ||
403 | (<x: i32>) | ||
404 | "#]], | ||
405 | ); | ||
406 | } | ||
407 | |||
408 | #[test] | ||
409 | fn test_fn_signature_for_method_with_arg_as_assoc_fn() { | ||
410 | check( | ||
411 | r#" | ||
412 | struct S; | ||
413 | impl S { | ||
414 | fn foo(&self, x: i32) {} | ||
415 | } | ||
416 | |||
417 | fn main() { S::foo(<|>); } | ||
418 | "#, | ||
419 | expect![[r#" | ||
420 | fn foo(self: &S, x: i32) | ||
421 | (<self: &S>, x: i32) | ||
422 | "#]], | ||
423 | ); | ||
424 | } | ||
425 | |||
426 | #[test] | ||
427 | fn test_fn_signature_with_docs_simple() { | ||
428 | check( | ||
429 | r#" | ||
430 | /// test | ||
431 | // non-doc-comment | ||
432 | fn foo(j: u32) -> u32 { | ||
433 | j | ||
434 | } | ||
435 | |||
436 | fn bar() { | ||
437 | let _ = foo(<|>); | ||
438 | } | ||
439 | "#, | ||
440 | expect![[r#" | ||
441 | test | ||
442 | ------ | ||
443 | fn foo(j: u32) -> u32 | ||
444 | (<j: u32>) | ||
445 | "#]], | ||
446 | ); | ||
447 | } | ||
448 | |||
449 | #[test] | ||
450 | fn test_fn_signature_with_docs() { | ||
451 | check( | ||
452 | r#" | ||
453 | /// Adds one to the number given. | ||
454 | /// | ||
455 | /// # Examples | ||
456 | /// | ||
457 | /// ``` | ||
458 | /// let five = 5; | ||
459 | /// | ||
460 | /// assert_eq!(6, my_crate::add_one(5)); | ||
461 | /// ``` | ||
462 | pub fn add_one(x: i32) -> i32 { | ||
463 | x + 1 | ||
464 | } | ||
465 | |||
466 | pub fn do() { | ||
467 | add_one(<|> | ||
468 | }"#, | ||
469 | expect![[r##" | ||
470 | Adds one to the number given. | ||
471 | |||
472 | # Examples | ||
473 | |||
474 | ``` | ||
475 | let five = 5; | ||
476 | |||
477 | assert_eq!(6, my_crate::add_one(5)); | ||
478 | ``` | ||
479 | ------ | ||
480 | fn add_one(x: i32) -> i32 | ||
481 | (<x: i32>) | ||
482 | "##]], | ||
483 | ); | ||
484 | } | ||
485 | |||
486 | #[test] | ||
487 | fn test_fn_signature_with_docs_impl() { | ||
488 | check( | ||
489 | r#" | ||
490 | struct addr; | ||
491 | impl addr { | ||
492 | /// Adds one to the number given. | ||
493 | /// | ||
494 | /// # Examples | ||
495 | /// | ||
496 | /// ``` | ||
497 | /// let five = 5; | ||
498 | /// | ||
499 | /// assert_eq!(6, my_crate::add_one(5)); | ||
500 | /// ``` | ||
501 | pub fn add_one(x: i32) -> i32 { | ||
502 | x + 1 | ||
503 | } | ||
504 | } | ||
505 | |||
506 | pub fn do_it() { | ||
507 | addr {}; | ||
508 | addr::add_one(<|>); | ||
509 | } | ||
510 | "#, | ||
511 | expect![[r##" | ||
512 | Adds one to the number given. | ||
513 | |||
514 | # Examples | ||
515 | |||
516 | ``` | ||
517 | let five = 5; | ||
518 | |||
519 | assert_eq!(6, my_crate::add_one(5)); | ||
520 | ``` | ||
521 | ------ | ||
522 | fn add_one(x: i32) -> i32 | ||
523 | (<x: i32>) | ||
524 | "##]], | ||
525 | ); | ||
526 | } | ||
527 | |||
528 | #[test] | ||
529 | fn test_fn_signature_with_docs_from_actix() { | ||
530 | check( | ||
531 | r#" | ||
532 | struct WriteHandler<E>; | ||
533 | |||
534 | impl<E> WriteHandler<E> { | ||
535 | /// Method is called when writer emits error. | ||
536 | /// | ||
537 | /// If this method returns `ErrorAction::Continue` writer processing | ||
538 | /// continues otherwise stream processing stops. | ||
539 | fn error(&mut self, err: E, ctx: &mut Self::Context) -> Running { | ||
540 | Running::Stop | ||
541 | } | ||
542 | |||
543 | /// Method is called when writer finishes. | ||
544 | /// | ||
545 | /// By default this method stops actor's `Context`. | ||
546 | fn finished(&mut self, ctx: &mut Self::Context) { | ||
547 | ctx.stop() | ||
548 | } | ||
549 | } | ||
550 | |||
551 | pub fn foo(mut r: WriteHandler<()>) { | ||
552 | r.finished(<|>); | ||
553 | } | ||
554 | "#, | ||
555 | expect![[r#" | ||
556 | Method is called when writer finishes. | ||
557 | |||
558 | By default this method stops actor's `Context`. | ||
559 | ------ | ||
560 | fn finished(&mut self, ctx: &mut {unknown}) | ||
561 | (<ctx: &mut {unknown}>) | ||
562 | "#]], | ||
563 | ); | ||
564 | } | ||
565 | |||
566 | #[test] | ||
567 | fn call_info_bad_offset() { | ||
568 | mark::check!(call_info_bad_offset); | ||
569 | check( | ||
570 | r#" | ||
571 | fn foo(x: u32, y: u32) -> u32 {x + y} | ||
572 | fn bar() { foo <|> (3, ); } | ||
573 | "#, | ||
574 | expect![[""]], | ||
575 | ); | ||
576 | } | ||
577 | |||
578 | #[test] | ||
579 | fn test_nested_method_in_lambda() { | ||
580 | check( | ||
581 | r#" | ||
582 | struct Foo; | ||
583 | impl Foo { fn bar(&self, _: u32) { } } | ||
584 | |||
585 | fn bar(_: u32) { } | ||
586 | |||
587 | fn main() { | ||
588 | let foo = Foo; | ||
589 | std::thread::spawn(move || foo.bar(<|>)); | ||
590 | } | ||
591 | "#, | ||
592 | expect![[r#" | ||
593 | fn bar(&self, _: u32) | ||
594 | (<_: u32>) | ||
595 | "#]], | ||
596 | ); | ||
597 | } | ||
598 | |||
599 | #[test] | ||
600 | fn works_for_tuple_structs() { | ||
601 | check( | ||
602 | r#" | ||
603 | /// A cool tuple struct | ||
604 | struct S(u32, i32); | ||
605 | fn main() { | ||
606 | let s = S(0, <|>); | ||
607 | } | ||
608 | "#, | ||
609 | expect![[r#" | ||
610 | A cool tuple struct | ||
611 | ------ | ||
612 | struct S(u32, i32) | ||
613 | (u32, <i32>) | ||
614 | "#]], | ||
615 | ); | ||
616 | } | ||
617 | |||
618 | #[test] | ||
619 | fn generic_struct() { | ||
620 | check( | ||
621 | r#" | ||
622 | struct S<T>(T); | ||
623 | fn main() { | ||
624 | let s = S(<|>); | ||
625 | } | ||
626 | "#, | ||
627 | expect![[r#" | ||
628 | struct S({unknown}) | ||
629 | (<{unknown}>) | ||
630 | "#]], | ||
631 | ); | ||
632 | } | ||
633 | |||
634 | #[test] | ||
635 | fn works_for_enum_variants() { | ||
636 | check( | ||
637 | r#" | ||
638 | enum E { | ||
639 | /// A Variant | ||
640 | A(i32), | ||
641 | /// Another | ||
642 | B, | ||
643 | /// And C | ||
644 | C { a: i32, b: i32 } | ||
645 | } | ||
646 | |||
647 | fn main() { | ||
648 | let a = E::A(<|>); | ||
649 | } | ||
650 | "#, | ||
651 | expect![[r#" | ||
652 | A Variant | ||
653 | ------ | ||
654 | enum E::A(i32) | ||
655 | (<i32>) | ||
656 | "#]], | ||
657 | ); | ||
658 | } | ||
659 | |||
660 | #[test] | ||
661 | fn cant_call_struct_record() { | ||
662 | check( | ||
663 | r#" | ||
664 | struct S { x: u32, y: i32 } | ||
665 | fn main() { | ||
666 | let s = S(<|>); | ||
667 | } | ||
668 | "#, | ||
669 | expect![[""]], | ||
670 | ); | ||
671 | } | ||
672 | |||
673 | #[test] | ||
674 | fn cant_call_enum_record() { | ||
675 | check( | ||
676 | r#" | ||
677 | enum E { | ||
678 | /// A Variant | ||
679 | A(i32), | ||
680 | /// Another | ||
681 | B, | ||
682 | /// And C | ||
683 | C { a: i32, b: i32 } | ||
684 | } | ||
685 | |||
686 | fn main() { | ||
687 | let a = E::C(<|>); | ||
688 | } | ||
689 | "#, | ||
690 | expect![[""]], | ||
691 | ); | ||
692 | } | ||
693 | |||
694 | #[test] | ||
695 | fn fn_signature_for_call_in_macro() { | ||
696 | check( | ||
697 | r#" | ||
698 | macro_rules! id { ($($tt:tt)*) => { $($tt)* } } | ||
699 | fn foo() { } | ||
700 | id! { | ||
701 | fn bar() { foo(<|>); } | ||
702 | } | ||
703 | "#, | ||
704 | expect![[r#" | ||
705 | fn foo() | ||
706 | () | ||
707 | "#]], | ||
708 | ); | ||
709 | } | ||
710 | |||
711 | #[test] | ||
712 | fn call_info_for_lambdas() { | ||
713 | check( | ||
714 | r#" | ||
715 | struct S; | ||
716 | fn foo(s: S) -> i32 { 92 } | ||
717 | fn main() { | ||
718 | (|s| foo(s))(<|>) | ||
719 | } | ||
720 | "#, | ||
721 | expect![[r#" | ||
722 | (S) -> i32 | ||
723 | (<S>) | ||
724 | "#]], | ||
725 | ) | ||
726 | } | ||
727 | |||
728 | #[test] | ||
729 | fn call_info_for_fn_ptr() { | ||
730 | check( | ||
731 | r#" | ||
732 | fn main(f: fn(i32, f64) -> char) { | ||
733 | f(0, <|>) | ||
734 | } | ||
735 | "#, | ||
736 | expect![[r#" | ||
737 | (i32, f64) -> char | ||
738 | (i32, <f64>) | ||
739 | "#]], | ||
740 | ) | ||
741 | } | ||
742 | } | ||