diff options
Diffstat (limited to 'crates/ide/src/hover.rs')
-rw-r--r-- | crates/ide/src/hover.rs | 2967 |
1 files changed, 2967 insertions, 0 deletions
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs new file mode 100644 index 000000000..b012e4900 --- /dev/null +++ b/crates/ide/src/hover.rs | |||
@@ -0,0 +1,2967 @@ | |||
1 | use base_db::SourceDatabase; | ||
2 | use hir::{ | ||
3 | Adt, AsAssocItem, AssocItemContainer, Documentation, FieldSource, HasSource, HirDisplay, | ||
4 | Module, ModuleDef, ModuleSource, Semantics, | ||
5 | }; | ||
6 | use ide_db::{ | ||
7 | defs::{classify_name, classify_name_ref, Definition}, | ||
8 | RootDatabase, | ||
9 | }; | ||
10 | use itertools::Itertools; | ||
11 | use stdx::format_to; | ||
12 | use syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset, T}; | ||
13 | use test_utils::mark; | ||
14 | |||
15 | use crate::{ | ||
16 | display::{macro_label, ShortLabel, ToNav, TryToNav}, | ||
17 | link_rewrite::rewrite_links, | ||
18 | markup::Markup, | ||
19 | runnables::runnable, | ||
20 | FileId, FilePosition, NavigationTarget, RangeInfo, Runnable, | ||
21 | }; | ||
22 | |||
23 | #[derive(Clone, Debug, PartialEq, Eq)] | ||
24 | pub struct HoverConfig { | ||
25 | pub implementations: bool, | ||
26 | pub run: bool, | ||
27 | pub debug: bool, | ||
28 | pub goto_type_def: bool, | ||
29 | } | ||
30 | |||
31 | impl Default for HoverConfig { | ||
32 | fn default() -> Self { | ||
33 | Self { implementations: true, run: true, debug: true, goto_type_def: true } | ||
34 | } | ||
35 | } | ||
36 | |||
37 | impl HoverConfig { | ||
38 | pub const NO_ACTIONS: Self = | ||
39 | Self { implementations: false, run: false, debug: false, goto_type_def: false }; | ||
40 | |||
41 | pub fn any(&self) -> bool { | ||
42 | self.implementations || self.runnable() || self.goto_type_def | ||
43 | } | ||
44 | |||
45 | pub fn none(&self) -> bool { | ||
46 | !self.any() | ||
47 | } | ||
48 | |||
49 | pub fn runnable(&self) -> bool { | ||
50 | self.run || self.debug | ||
51 | } | ||
52 | } | ||
53 | |||
54 | #[derive(Debug, Clone)] | ||
55 | pub enum HoverAction { | ||
56 | Runnable(Runnable), | ||
57 | Implementaion(FilePosition), | ||
58 | GoToType(Vec<HoverGotoTypeData>), | ||
59 | } | ||
60 | |||
61 | #[derive(Debug, Clone, Eq, PartialEq)] | ||
62 | pub struct HoverGotoTypeData { | ||
63 | pub mod_path: String, | ||
64 | pub nav: NavigationTarget, | ||
65 | } | ||
66 | |||
67 | /// Contains the results when hovering over an item | ||
68 | #[derive(Debug, Default)] | ||
69 | pub struct HoverResult { | ||
70 | pub markup: Markup, | ||
71 | pub actions: Vec<HoverAction>, | ||
72 | } | ||
73 | |||
74 | // Feature: Hover | ||
75 | // | ||
76 | // Shows additional information, like type of an expression or documentation for definition when "focusing" code. | ||
77 | // Focusing is usually hovering with a mouse, but can also be triggered with a shortcut. | ||
78 | pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo<HoverResult>> { | ||
79 | let sema = Semantics::new(db); | ||
80 | let file = sema.parse(position.file_id).syntax().clone(); | ||
81 | let token = pick_best(file.token_at_offset(position.offset))?; | ||
82 | let token = sema.descend_into_macros(token); | ||
83 | |||
84 | let mut res = HoverResult::default(); | ||
85 | |||
86 | let node = token.parent(); | ||
87 | let definition = match_ast! { | ||
88 | match node { | ||
89 | ast::NameRef(name_ref) => classify_name_ref(&sema, &name_ref).map(|d| d.definition(sema.db)), | ||
90 | ast::Name(name) => classify_name(&sema, &name).map(|d| d.definition(sema.db)), | ||
91 | _ => None, | ||
92 | } | ||
93 | }; | ||
94 | if let Some(definition) = definition { | ||
95 | if let Some(markup) = hover_for_definition(db, definition) { | ||
96 | let markup = rewrite_links(db, &markup.as_str(), &definition); | ||
97 | res.markup = Markup::from(markup); | ||
98 | if let Some(action) = show_implementations_action(db, definition) { | ||
99 | res.actions.push(action); | ||
100 | } | ||
101 | |||
102 | if let Some(action) = runnable_action(&sema, definition, position.file_id) { | ||
103 | res.actions.push(action); | ||
104 | } | ||
105 | |||
106 | if let Some(action) = goto_type_action(db, definition) { | ||
107 | res.actions.push(action); | ||
108 | } | ||
109 | |||
110 | let range = sema.original_range(&node).range; | ||
111 | return Some(RangeInfo::new(range, res)); | ||
112 | } | ||
113 | } | ||
114 | |||
115 | let node = token | ||
116 | .ancestors() | ||
117 | .find(|n| ast::Expr::cast(n.clone()).is_some() || ast::Pat::cast(n.clone()).is_some())?; | ||
118 | |||
119 | let ty = match_ast! { | ||
120 | match node { | ||
121 | ast::Expr(it) => sema.type_of_expr(&it)?, | ||
122 | ast::Pat(it) => sema.type_of_pat(&it)?, | ||
123 | // If this node is a MACRO_CALL, it means that `descend_into_macros` failed to resolve. | ||
124 | // (e.g expanding a builtin macro). So we give up here. | ||
125 | ast::MacroCall(_it) => return None, | ||
126 | _ => return None, | ||
127 | } | ||
128 | }; | ||
129 | |||
130 | res.markup = Markup::fenced_block(&ty.display(db)); | ||
131 | let range = sema.original_range(&node).range; | ||
132 | Some(RangeInfo::new(range, res)) | ||
133 | } | ||
134 | |||
135 | fn show_implementations_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> { | ||
136 | fn to_action(nav_target: NavigationTarget) -> HoverAction { | ||
137 | HoverAction::Implementaion(FilePosition { | ||
138 | file_id: nav_target.file_id, | ||
139 | offset: nav_target.focus_or_full_range().start(), | ||
140 | }) | ||
141 | } | ||
142 | |||
143 | match def { | ||
144 | Definition::ModuleDef(it) => match it { | ||
145 | ModuleDef::Adt(Adt::Struct(it)) => Some(to_action(it.to_nav(db))), | ||
146 | ModuleDef::Adt(Adt::Union(it)) => Some(to_action(it.to_nav(db))), | ||
147 | ModuleDef::Adt(Adt::Enum(it)) => Some(to_action(it.to_nav(db))), | ||
148 | ModuleDef::Trait(it) => Some(to_action(it.to_nav(db))), | ||
149 | _ => None, | ||
150 | }, | ||
151 | _ => None, | ||
152 | } | ||
153 | } | ||
154 | |||
155 | fn runnable_action( | ||
156 | sema: &Semantics<RootDatabase>, | ||
157 | def: Definition, | ||
158 | file_id: FileId, | ||
159 | ) -> Option<HoverAction> { | ||
160 | match def { | ||
161 | Definition::ModuleDef(it) => match it { | ||
162 | ModuleDef::Module(it) => match it.definition_source(sema.db).value { | ||
163 | ModuleSource::Module(it) => runnable(&sema, it.syntax().clone(), file_id) | ||
164 | .map(|it| HoverAction::Runnable(it)), | ||
165 | _ => None, | ||
166 | }, | ||
167 | ModuleDef::Function(it) => { | ||
168 | let src = it.source(sema.db); | ||
169 | if src.file_id != file_id.into() { | ||
170 | mark::hit!(hover_macro_generated_struct_fn_doc_comment); | ||
171 | mark::hit!(hover_macro_generated_struct_fn_doc_attr); | ||
172 | |||
173 | return None; | ||
174 | } | ||
175 | |||
176 | runnable(&sema, src.value.syntax().clone(), file_id) | ||
177 | .map(|it| HoverAction::Runnable(it)) | ||
178 | } | ||
179 | _ => None, | ||
180 | }, | ||
181 | _ => None, | ||
182 | } | ||
183 | } | ||
184 | |||
185 | fn goto_type_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> { | ||
186 | match def { | ||
187 | Definition::Local(it) => { | ||
188 | let mut targets: Vec<ModuleDef> = Vec::new(); | ||
189 | let mut push_new_def = |item: ModuleDef| { | ||
190 | if !targets.contains(&item) { | ||
191 | targets.push(item); | ||
192 | } | ||
193 | }; | ||
194 | |||
195 | it.ty(db).walk(db, |t| { | ||
196 | if let Some(adt) = t.as_adt() { | ||
197 | push_new_def(adt.into()); | ||
198 | } else if let Some(trait_) = t.as_dyn_trait() { | ||
199 | push_new_def(trait_.into()); | ||
200 | } else if let Some(traits) = t.as_impl_traits(db) { | ||
201 | traits.into_iter().for_each(|it| push_new_def(it.into())); | ||
202 | } else if let Some(trait_) = t.as_associated_type_parent_trait(db) { | ||
203 | push_new_def(trait_.into()); | ||
204 | } | ||
205 | }); | ||
206 | |||
207 | let targets = targets | ||
208 | .into_iter() | ||
209 | .filter_map(|it| { | ||
210 | Some(HoverGotoTypeData { | ||
211 | mod_path: render_path( | ||
212 | db, | ||
213 | it.module(db)?, | ||
214 | it.name(db).map(|name| name.to_string()), | ||
215 | ), | ||
216 | nav: it.try_to_nav(db)?, | ||
217 | }) | ||
218 | }) | ||
219 | .collect(); | ||
220 | |||
221 | Some(HoverAction::GoToType(targets)) | ||
222 | } | ||
223 | _ => None, | ||
224 | } | ||
225 | } | ||
226 | |||
227 | fn hover_markup( | ||
228 | docs: Option<String>, | ||
229 | desc: Option<String>, | ||
230 | mod_path: Option<String>, | ||
231 | ) -> Option<Markup> { | ||
232 | match desc { | ||
233 | Some(desc) => { | ||
234 | let mut buf = String::new(); | ||
235 | |||
236 | if let Some(mod_path) = mod_path { | ||
237 | if !mod_path.is_empty() { | ||
238 | format_to!(buf, "```rust\n{}\n```\n\n", mod_path); | ||
239 | } | ||
240 | } | ||
241 | format_to!(buf, "```rust\n{}\n```", desc); | ||
242 | |||
243 | if let Some(doc) = docs { | ||
244 | format_to!(buf, "\n___\n\n{}", doc); | ||
245 | } | ||
246 | Some(buf.into()) | ||
247 | } | ||
248 | None => docs.map(Markup::from), | ||
249 | } | ||
250 | } | ||
251 | |||
252 | fn definition_owner_name(db: &RootDatabase, def: &Definition) -> Option<String> { | ||
253 | match def { | ||
254 | Definition::Field(f) => Some(f.parent_def(db).name(db)), | ||
255 | Definition::Local(l) => l.parent(db).name(db), | ||
256 | Definition::ModuleDef(md) => match md { | ||
257 | ModuleDef::Function(f) => match f.as_assoc_item(db)?.container(db) { | ||
258 | AssocItemContainer::Trait(t) => Some(t.name(db)), | ||
259 | AssocItemContainer::ImplDef(i) => i.target_ty(db).as_adt().map(|adt| adt.name(db)), | ||
260 | }, | ||
261 | ModuleDef::EnumVariant(e) => Some(e.parent_enum(db).name(db)), | ||
262 | _ => None, | ||
263 | }, | ||
264 | Definition::SelfType(i) => i.target_ty(db).as_adt().map(|adt| adt.name(db)), | ||
265 | _ => None, | ||
266 | } | ||
267 | .map(|name| name.to_string()) | ||
268 | } | ||
269 | |||
270 | fn render_path(db: &RootDatabase, module: Module, item_name: Option<String>) -> String { | ||
271 | let crate_name = | ||
272 | db.crate_graph()[module.krate().into()].display_name.as_ref().map(ToString::to_string); | ||
273 | let module_path = module | ||
274 | .path_to_root(db) | ||
275 | .into_iter() | ||
276 | .rev() | ||
277 | .flat_map(|it| it.name(db).map(|name| name.to_string())); | ||
278 | crate_name.into_iter().chain(module_path).chain(item_name).join("::") | ||
279 | } | ||
280 | |||
281 | fn definition_mod_path(db: &RootDatabase, def: &Definition) -> Option<String> { | ||
282 | def.module(db).map(|module| render_path(db, module, definition_owner_name(db, def))) | ||
283 | } | ||
284 | |||
285 | fn hover_for_definition(db: &RootDatabase, def: Definition) -> Option<Markup> { | ||
286 | let mod_path = definition_mod_path(db, &def); | ||
287 | return match def { | ||
288 | Definition::Macro(it) => { | ||
289 | let src = it.source(db); | ||
290 | let docs = Documentation::from_ast(&src.value).map(Into::into); | ||
291 | hover_markup(docs, Some(macro_label(&src.value)), mod_path) | ||
292 | } | ||
293 | Definition::Field(it) => { | ||
294 | let src = it.source(db); | ||
295 | match src.value { | ||
296 | FieldSource::Named(it) => { | ||
297 | let docs = Documentation::from_ast(&it).map(Into::into); | ||
298 | hover_markup(docs, it.short_label(), mod_path) | ||
299 | } | ||
300 | _ => None, | ||
301 | } | ||
302 | } | ||
303 | Definition::ModuleDef(it) => match it { | ||
304 | ModuleDef::Module(it) => match it.definition_source(db).value { | ||
305 | ModuleSource::Module(it) => { | ||
306 | let docs = Documentation::from_ast(&it).map(Into::into); | ||
307 | hover_markup(docs, it.short_label(), mod_path) | ||
308 | } | ||
309 | ModuleSource::SourceFile(it) => { | ||
310 | let docs = Documentation::from_ast(&it).map(Into::into); | ||
311 | hover_markup(docs, it.short_label(), mod_path) | ||
312 | } | ||
313 | }, | ||
314 | ModuleDef::Function(it) => from_def_source(db, it, mod_path), | ||
315 | ModuleDef::Adt(Adt::Struct(it)) => from_def_source(db, it, mod_path), | ||
316 | ModuleDef::Adt(Adt::Union(it)) => from_def_source(db, it, mod_path), | ||
317 | ModuleDef::Adt(Adt::Enum(it)) => from_def_source(db, it, mod_path), | ||
318 | ModuleDef::EnumVariant(it) => from_def_source(db, it, mod_path), | ||
319 | ModuleDef::Const(it) => from_def_source(db, it, mod_path), | ||
320 | ModuleDef::Static(it) => from_def_source(db, it, mod_path), | ||
321 | ModuleDef::Trait(it) => from_def_source(db, it, mod_path), | ||
322 | ModuleDef::TypeAlias(it) => from_def_source(db, it, mod_path), | ||
323 | ModuleDef::BuiltinType(it) => return Some(it.to_string().into()), | ||
324 | }, | ||
325 | Definition::Local(it) => return Some(Markup::fenced_block(&it.ty(db).display(db))), | ||
326 | Definition::TypeParam(_) | Definition::SelfType(_) => { | ||
327 | // FIXME: Hover for generic param | ||
328 | None | ||
329 | } | ||
330 | }; | ||
331 | |||
332 | fn from_def_source<A, D>(db: &RootDatabase, def: D, mod_path: Option<String>) -> Option<Markup> | ||
333 | where | ||
334 | D: HasSource<Ast = A>, | ||
335 | A: ast::DocCommentsOwner + ast::NameOwner + ShortLabel + ast::AttrsOwner, | ||
336 | { | ||
337 | let src = def.source(db); | ||
338 | let docs = Documentation::from_ast(&src.value).map(Into::into); | ||
339 | hover_markup(docs, src.value.short_label(), mod_path) | ||
340 | } | ||
341 | } | ||
342 | |||
343 | fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> { | ||
344 | return tokens.max_by_key(priority); | ||
345 | fn priority(n: &SyntaxToken) -> usize { | ||
346 | match n.kind() { | ||
347 | IDENT | INT_NUMBER => 3, | ||
348 | T!['('] | T![')'] => 2, | ||
349 | kind if kind.is_trivia() => 0, | ||
350 | _ => 1, | ||
351 | } | ||
352 | } | ||
353 | } | ||
354 | |||
355 | #[cfg(test)] | ||
356 | mod tests { | ||
357 | use base_db::FileLoader; | ||
358 | use expect_test::{expect, Expect}; | ||
359 | |||
360 | use crate::mock_analysis::analysis_and_position; | ||
361 | |||
362 | use super::*; | ||
363 | |||
364 | fn check_hover_no_result(ra_fixture: &str) { | ||
365 | let (analysis, position) = analysis_and_position(ra_fixture); | ||
366 | assert!(analysis.hover(position).unwrap().is_none()); | ||
367 | } | ||
368 | |||
369 | fn check(ra_fixture: &str, expect: Expect) { | ||
370 | let (analysis, position) = analysis_and_position(ra_fixture); | ||
371 | let hover = analysis.hover(position).unwrap().unwrap(); | ||
372 | |||
373 | let content = analysis.db.file_text(position.file_id); | ||
374 | let hovered_element = &content[hover.range]; | ||
375 | |||
376 | let actual = format!("*{}*\n{}\n", hovered_element, hover.info.markup); | ||
377 | expect.assert_eq(&actual) | ||
378 | } | ||
379 | |||
380 | fn check_actions(ra_fixture: &str, expect: Expect) { | ||
381 | let (analysis, position) = analysis_and_position(ra_fixture); | ||
382 | let hover = analysis.hover(position).unwrap().unwrap(); | ||
383 | expect.assert_debug_eq(&hover.info.actions) | ||
384 | } | ||
385 | |||
386 | #[test] | ||
387 | fn hover_shows_type_of_an_expression() { | ||
388 | check( | ||
389 | r#" | ||
390 | pub fn foo() -> u32 { 1 } | ||
391 | |||
392 | fn main() { | ||
393 | let foo_test = foo()<|>; | ||
394 | } | ||
395 | "#, | ||
396 | expect![[r#" | ||
397 | *foo()* | ||
398 | ```rust | ||
399 | u32 | ||
400 | ``` | ||
401 | "#]], | ||
402 | ); | ||
403 | } | ||
404 | |||
405 | #[test] | ||
406 | fn hover_shows_long_type_of_an_expression() { | ||
407 | check( | ||
408 | r#" | ||
409 | struct Scan<A, B, C> { a: A, b: B, c: C } | ||
410 | struct Iter<I> { inner: I } | ||
411 | enum Option<T> { Some(T), None } | ||
412 | |||
413 | struct OtherStruct<T> { i: T } | ||
414 | |||
415 | fn scan<A, B, C>(a: A, b: B, c: C) -> Iter<Scan<OtherStruct<A>, B, C>> { | ||
416 | Iter { inner: Scan { a, b, c } } | ||
417 | } | ||
418 | |||
419 | fn main() { | ||
420 | let num: i32 = 55; | ||
421 | let closure = |memo: &mut u32, value: &u32, _another: &mut u32| -> Option<u32> { | ||
422 | Option::Some(*memo + value) | ||
423 | }; | ||
424 | let number = 5u32; | ||
425 | let mut iter<|> = scan(OtherStruct { i: num }, closure, number); | ||
426 | } | ||
427 | "#, | ||
428 | expect![[r#" | ||
429 | *iter* | ||
430 | |||
431 | ```rust | ||
432 | Iter<Scan<OtherStruct<OtherStruct<i32>>, |&mut u32, &u32, &mut u32| -> Option<u32>, u32>> | ||
433 | ``` | ||
434 | "#]], | ||
435 | ); | ||
436 | } | ||
437 | |||
438 | #[test] | ||
439 | fn hover_shows_fn_signature() { | ||
440 | // Single file with result | ||
441 | check( | ||
442 | r#" | ||
443 | pub fn foo() -> u32 { 1 } | ||
444 | |||
445 | fn main() { let foo_test = fo<|>o(); } | ||
446 | "#, | ||
447 | expect![[r#" | ||
448 | *foo* | ||
449 | |||
450 | ```rust | ||
451 | test | ||
452 | ``` | ||
453 | |||
454 | ```rust | ||
455 | pub fn foo() -> u32 | ||
456 | ``` | ||
457 | "#]], | ||
458 | ); | ||
459 | |||
460 | // Multiple candidates but results are ambiguous. | ||
461 | check( | ||
462 | r#" | ||
463 | //- /a.rs | ||
464 | pub fn foo() -> u32 { 1 } | ||
465 | |||
466 | //- /b.rs | ||
467 | pub fn foo() -> &str { "" } | ||
468 | |||
469 | //- /c.rs | ||
470 | pub fn foo(a: u32, b: u32) {} | ||
471 | |||
472 | //- /main.rs | ||
473 | mod a; | ||
474 | mod b; | ||
475 | mod c; | ||
476 | |||
477 | fn main() { let foo_test = fo<|>o(); } | ||
478 | "#, | ||
479 | expect![[r#" | ||
480 | *foo* | ||
481 | ```rust | ||
482 | {unknown} | ||
483 | ``` | ||
484 | "#]], | ||
485 | ); | ||
486 | } | ||
487 | |||
488 | #[test] | ||
489 | fn hover_shows_fn_signature_with_type_params() { | ||
490 | check( | ||
491 | r#" | ||
492 | pub fn foo<'a, T: AsRef<str>>(b: &'a T) -> &'a str { } | ||
493 | |||
494 | fn main() { let foo_test = fo<|>o(); } | ||
495 | "#, | ||
496 | expect![[r#" | ||
497 | *foo* | ||
498 | |||
499 | ```rust | ||
500 | test | ||
501 | ``` | ||
502 | |||
503 | ```rust | ||
504 | pub fn foo<'a, T: AsRef<str>>(b: &'a T) -> &'a str | ||
505 | ``` | ||
506 | "#]], | ||
507 | ); | ||
508 | } | ||
509 | |||
510 | #[test] | ||
511 | fn hover_shows_fn_signature_on_fn_name() { | ||
512 | check( | ||
513 | r#" | ||
514 | pub fn foo<|>(a: u32, b: u32) -> u32 {} | ||
515 | |||
516 | fn main() { } | ||
517 | "#, | ||
518 | expect![[r#" | ||
519 | *foo* | ||
520 | |||
521 | ```rust | ||
522 | test | ||
523 | ``` | ||
524 | |||
525 | ```rust | ||
526 | pub fn foo(a: u32, b: u32) -> u32 | ||
527 | ``` | ||
528 | "#]], | ||
529 | ); | ||
530 | } | ||
531 | |||
532 | #[test] | ||
533 | fn hover_shows_fn_doc() { | ||
534 | check( | ||
535 | r#" | ||
536 | /// # Example | ||
537 | /// ``` | ||
538 | /// # use std::path::Path; | ||
539 | /// # | ||
540 | /// foo(Path::new("hello, world!")) | ||
541 | /// ``` | ||
542 | pub fn foo<|>(_: &Path) {} | ||
543 | |||
544 | fn main() { } | ||
545 | "#, | ||
546 | expect![[r##" | ||
547 | *foo* | ||
548 | |||
549 | ```rust | ||
550 | test | ||
551 | ``` | ||
552 | |||
553 | ```rust | ||
554 | pub fn foo(_: &Path) | ||
555 | ``` | ||
556 | |||
557 | --- | ||
558 | |||
559 | # Example | ||
560 | |||
561 | ``` | ||
562 | # use std::path::Path; | ||
563 | # | ||
564 | foo(Path::new("hello, world!")) | ||
565 | ``` | ||
566 | "##]], | ||
567 | ); | ||
568 | } | ||
569 | |||
570 | #[test] | ||
571 | fn hover_shows_struct_field_info() { | ||
572 | // Hovering over the field when instantiating | ||
573 | check( | ||
574 | r#" | ||
575 | struct Foo { field_a: u32 } | ||
576 | |||
577 | fn main() { | ||
578 | let foo = Foo { field_a<|>: 0, }; | ||
579 | } | ||
580 | "#, | ||
581 | expect![[r#" | ||
582 | *field_a* | ||
583 | |||
584 | ```rust | ||
585 | test::Foo | ||
586 | ``` | ||
587 | |||
588 | ```rust | ||
589 | field_a: u32 | ||
590 | ``` | ||
591 | "#]], | ||
592 | ); | ||
593 | |||
594 | // Hovering over the field in the definition | ||
595 | check( | ||
596 | r#" | ||
597 | struct Foo { field_a<|>: u32 } | ||
598 | |||
599 | fn main() { | ||
600 | let foo = Foo { field_a: 0 }; | ||
601 | } | ||
602 | "#, | ||
603 | expect![[r#" | ||
604 | *field_a* | ||
605 | |||
606 | ```rust | ||
607 | test::Foo | ||
608 | ``` | ||
609 | |||
610 | ```rust | ||
611 | field_a: u32 | ||
612 | ``` | ||
613 | "#]], | ||
614 | ); | ||
615 | } | ||
616 | |||
617 | #[test] | ||
618 | fn hover_const_static() { | ||
619 | check( | ||
620 | r#"const foo<|>: u32 = 123;"#, | ||
621 | expect![[r#" | ||
622 | *foo* | ||
623 | |||
624 | ```rust | ||
625 | test | ||
626 | ``` | ||
627 | |||
628 | ```rust | ||
629 | const foo: u32 = 123 | ||
630 | ``` | ||
631 | "#]], | ||
632 | ); | ||
633 | check( | ||
634 | r#"static foo<|>: u32 = 456;"#, | ||
635 | expect![[r#" | ||
636 | *foo* | ||
637 | |||
638 | ```rust | ||
639 | test | ||
640 | ``` | ||
641 | |||
642 | ```rust | ||
643 | static foo: u32 | ||
644 | ``` | ||
645 | "#]], | ||
646 | ); | ||
647 | } | ||
648 | |||
649 | #[test] | ||
650 | fn hover_default_generic_types() { | ||
651 | check( | ||
652 | r#" | ||
653 | struct Test<K, T = u8> { k: K, t: T } | ||
654 | |||
655 | fn main() { | ||
656 | let zz<|> = Test { t: 23u8, k: 33 }; | ||
657 | }"#, | ||
658 | expect![[r#" | ||
659 | *zz* | ||
660 | |||
661 | ```rust | ||
662 | Test<i32, u8> | ||
663 | ``` | ||
664 | "#]], | ||
665 | ); | ||
666 | } | ||
667 | |||
668 | #[test] | ||
669 | fn hover_some() { | ||
670 | check( | ||
671 | r#" | ||
672 | enum Option<T> { Some(T) } | ||
673 | use Option::Some; | ||
674 | |||
675 | fn main() { So<|>me(12); } | ||
676 | "#, | ||
677 | expect![[r#" | ||
678 | *Some* | ||
679 | |||
680 | ```rust | ||
681 | test::Option | ||
682 | ``` | ||
683 | |||
684 | ```rust | ||
685 | Some | ||
686 | ``` | ||
687 | "#]], | ||
688 | ); | ||
689 | |||
690 | check( | ||
691 | r#" | ||
692 | enum Option<T> { Some(T) } | ||
693 | use Option::Some; | ||
694 | |||
695 | fn main() { let b<|>ar = Some(12); } | ||
696 | "#, | ||
697 | expect![[r#" | ||
698 | *bar* | ||
699 | |||
700 | ```rust | ||
701 | Option<i32> | ||
702 | ``` | ||
703 | "#]], | ||
704 | ); | ||
705 | } | ||
706 | |||
707 | #[test] | ||
708 | fn hover_enum_variant() { | ||
709 | check( | ||
710 | r#" | ||
711 | enum Option<T> { | ||
712 | /// The None variant | ||
713 | Non<|>e | ||
714 | } | ||
715 | "#, | ||
716 | expect![[r#" | ||
717 | *None* | ||
718 | |||
719 | ```rust | ||
720 | test::Option | ||
721 | ``` | ||
722 | |||
723 | ```rust | ||
724 | None | ||
725 | ``` | ||
726 | |||
727 | --- | ||
728 | |||
729 | The None variant | ||
730 | "#]], | ||
731 | ); | ||
732 | |||
733 | check( | ||
734 | r#" | ||
735 | enum Option<T> { | ||
736 | /// The Some variant | ||
737 | Some(T) | ||
738 | } | ||
739 | fn main() { | ||
740 | let s = Option::Som<|>e(12); | ||
741 | } | ||
742 | "#, | ||
743 | expect![[r#" | ||
744 | *Some* | ||
745 | |||
746 | ```rust | ||
747 | test::Option | ||
748 | ``` | ||
749 | |||
750 | ```rust | ||
751 | Some | ||
752 | ``` | ||
753 | |||
754 | --- | ||
755 | |||
756 | The Some variant | ||
757 | "#]], | ||
758 | ); | ||
759 | } | ||
760 | |||
761 | #[test] | ||
762 | fn hover_for_local_variable() { | ||
763 | check( | ||
764 | r#"fn func(foo: i32) { fo<|>o; }"#, | ||
765 | expect![[r#" | ||
766 | *foo* | ||
767 | |||
768 | ```rust | ||
769 | i32 | ||
770 | ``` | ||
771 | "#]], | ||
772 | ) | ||
773 | } | ||
774 | |||
775 | #[test] | ||
776 | fn hover_for_local_variable_pat() { | ||
777 | check( | ||
778 | r#"fn func(fo<|>o: i32) {}"#, | ||
779 | expect![[r#" | ||
780 | *foo* | ||
781 | |||
782 | ```rust | ||
783 | i32 | ||
784 | ``` | ||
785 | "#]], | ||
786 | ) | ||
787 | } | ||
788 | |||
789 | #[test] | ||
790 | fn hover_local_var_edge() { | ||
791 | check( | ||
792 | r#"fn func(foo: i32) { if true { <|>foo; }; }"#, | ||
793 | expect![[r#" | ||
794 | *foo* | ||
795 | |||
796 | ```rust | ||
797 | i32 | ||
798 | ``` | ||
799 | "#]], | ||
800 | ) | ||
801 | } | ||
802 | |||
803 | #[test] | ||
804 | fn hover_for_param_edge() { | ||
805 | check( | ||
806 | r#"fn func(<|>foo: i32) {}"#, | ||
807 | expect![[r#" | ||
808 | *foo* | ||
809 | |||
810 | ```rust | ||
811 | i32 | ||
812 | ``` | ||
813 | "#]], | ||
814 | ) | ||
815 | } | ||
816 | |||
817 | #[test] | ||
818 | fn hover_for_param_with_multiple_traits() { | ||
819 | check( | ||
820 | r#"trait Deref { | ||
821 | type Target: ?Sized; | ||
822 | } | ||
823 | trait DerefMut { | ||
824 | type Target: ?Sized; | ||
825 | } | ||
826 | fn f(_x<|>: impl Deref<Target=u8> + DerefMut<Target=u8>) {}"#, | ||
827 | expect![[r#" | ||
828 | *_x* | ||
829 | |||
830 | ```rust | ||
831 | impl Deref<Target = u8> + DerefMut<Target = u8> | ||
832 | ``` | ||
833 | "#]], | ||
834 | ) | ||
835 | } | ||
836 | |||
837 | #[test] | ||
838 | fn test_hover_infer_associated_method_result() { | ||
839 | check( | ||
840 | r#" | ||
841 | struct Thing { x: u32 } | ||
842 | |||
843 | impl Thing { | ||
844 | fn new() -> Thing { Thing { x: 0 } } | ||
845 | } | ||
846 | |||
847 | fn main() { let foo_<|>test = Thing::new(); } | ||
848 | "#, | ||
849 | expect![[r#" | ||
850 | *foo_test* | ||
851 | |||
852 | ```rust | ||
853 | Thing | ||
854 | ``` | ||
855 | "#]], | ||
856 | ) | ||
857 | } | ||
858 | |||
859 | #[test] | ||
860 | fn test_hover_infer_associated_method_exact() { | ||
861 | check( | ||
862 | r#" | ||
863 | mod wrapper { | ||
864 | struct Thing { x: u32 } | ||
865 | |||
866 | impl Thing { | ||
867 | fn new() -> Thing { Thing { x: 0 } } | ||
868 | } | ||
869 | } | ||
870 | |||
871 | fn main() { let foo_test = wrapper::Thing::new<|>(); } | ||
872 | "#, | ||
873 | expect![[r#" | ||
874 | *new* | ||
875 | |||
876 | ```rust | ||
877 | test::wrapper::Thing | ||
878 | ``` | ||
879 | |||
880 | ```rust | ||
881 | fn new() -> Thing | ||
882 | ``` | ||
883 | "#]], | ||
884 | ) | ||
885 | } | ||
886 | |||
887 | #[test] | ||
888 | fn test_hover_infer_associated_const_in_pattern() { | ||
889 | check( | ||
890 | r#" | ||
891 | struct X; | ||
892 | impl X { | ||
893 | const C: u32 = 1; | ||
894 | } | ||
895 | |||
896 | fn main() { | ||
897 | match 1 { | ||
898 | X::C<|> => {}, | ||
899 | 2 => {}, | ||
900 | _ => {} | ||
901 | }; | ||
902 | } | ||
903 | "#, | ||
904 | expect![[r#" | ||
905 | *C* | ||
906 | |||
907 | ```rust | ||
908 | test | ||
909 | ``` | ||
910 | |||
911 | ```rust | ||
912 | const C: u32 = 1 | ||
913 | ``` | ||
914 | "#]], | ||
915 | ) | ||
916 | } | ||
917 | |||
918 | #[test] | ||
919 | fn test_hover_self() { | ||
920 | check( | ||
921 | r#" | ||
922 | struct Thing { x: u32 } | ||
923 | impl Thing { | ||
924 | fn new() -> Self { Self<|> { x: 0 } } | ||
925 | } | ||
926 | "#, | ||
927 | expect![[r#" | ||
928 | *Self { x: 0 }* | ||
929 | ```rust | ||
930 | Thing | ||
931 | ``` | ||
932 | "#]], | ||
933 | ) | ||
934 | } /* FIXME: revive these tests | ||
935 | let (analysis, position) = analysis_and_position( | ||
936 | " | ||
937 | struct Thing { x: u32 } | ||
938 | impl Thing { | ||
939 | fn new() -> Self<|> { | ||
940 | Self { x: 0 } | ||
941 | } | ||
942 | } | ||
943 | ", | ||
944 | ); | ||
945 | |||
946 | let hover = analysis.hover(position).unwrap().unwrap(); | ||
947 | assert_eq!(trim_markup(&hover.info.markup.as_str()), ("Thing")); | ||
948 | |||
949 | let (analysis, position) = analysis_and_position( | ||
950 | " | ||
951 | enum Thing { A } | ||
952 | impl Thing { | ||
953 | pub fn new() -> Self<|> { | ||
954 | Thing::A | ||
955 | } | ||
956 | } | ||
957 | ", | ||
958 | ); | ||
959 | let hover = analysis.hover(position).unwrap().unwrap(); | ||
960 | assert_eq!(trim_markup(&hover.info.markup.as_str()), ("enum Thing")); | ||
961 | |||
962 | let (analysis, position) = analysis_and_position( | ||
963 | " | ||
964 | enum Thing { A } | ||
965 | impl Thing { | ||
966 | pub fn thing(a: Self<|>) { | ||
967 | } | ||
968 | } | ||
969 | ", | ||
970 | ); | ||
971 | let hover = analysis.hover(position).unwrap().unwrap(); | ||
972 | assert_eq!(trim_markup(&hover.info.markup.as_str()), ("enum Thing")); | ||
973 | */ | ||
974 | |||
975 | #[test] | ||
976 | fn test_hover_shadowing_pat() { | ||
977 | check( | ||
978 | r#" | ||
979 | fn x() {} | ||
980 | |||
981 | fn y() { | ||
982 | let x = 0i32; | ||
983 | x<|>; | ||
984 | } | ||
985 | "#, | ||
986 | expect![[r#" | ||
987 | *x* | ||
988 | |||
989 | ```rust | ||
990 | i32 | ||
991 | ``` | ||
992 | "#]], | ||
993 | ) | ||
994 | } | ||
995 | |||
996 | #[test] | ||
997 | fn test_hover_macro_invocation() { | ||
998 | check( | ||
999 | r#" | ||
1000 | macro_rules! foo { () => {} } | ||
1001 | |||
1002 | fn f() { fo<|>o!(); } | ||
1003 | "#, | ||
1004 | expect![[r#" | ||
1005 | *foo* | ||
1006 | |||
1007 | ```rust | ||
1008 | test | ||
1009 | ``` | ||
1010 | |||
1011 | ```rust | ||
1012 | macro_rules! foo | ||
1013 | ``` | ||
1014 | "#]], | ||
1015 | ) | ||
1016 | } | ||
1017 | |||
1018 | #[test] | ||
1019 | fn test_hover_tuple_field() { | ||
1020 | check( | ||
1021 | r#"struct TS(String, i32<|>);"#, | ||
1022 | expect![[r#" | ||
1023 | *i32* | ||
1024 | i32 | ||
1025 | "#]], | ||
1026 | ) | ||
1027 | } | ||
1028 | |||
1029 | #[test] | ||
1030 | fn test_hover_through_macro() { | ||
1031 | check( | ||
1032 | r#" | ||
1033 | macro_rules! id { ($($tt:tt)*) => { $($tt)* } } | ||
1034 | fn foo() {} | ||
1035 | id! { | ||
1036 | fn bar() { fo<|>o(); } | ||
1037 | } | ||
1038 | "#, | ||
1039 | expect![[r#" | ||
1040 | *foo* | ||
1041 | |||
1042 | ```rust | ||
1043 | test | ||
1044 | ``` | ||
1045 | |||
1046 | ```rust | ||
1047 | fn foo() | ||
1048 | ``` | ||
1049 | "#]], | ||
1050 | ); | ||
1051 | } | ||
1052 | |||
1053 | #[test] | ||
1054 | fn test_hover_through_expr_in_macro() { | ||
1055 | check( | ||
1056 | r#" | ||
1057 | macro_rules! id { ($($tt:tt)*) => { $($tt)* } } | ||
1058 | fn foo(bar:u32) { let a = id!(ba<|>r); } | ||
1059 | "#, | ||
1060 | expect![[r#" | ||
1061 | *bar* | ||
1062 | |||
1063 | ```rust | ||
1064 | u32 | ||
1065 | ``` | ||
1066 | "#]], | ||
1067 | ); | ||
1068 | } | ||
1069 | |||
1070 | #[test] | ||
1071 | fn test_hover_through_expr_in_macro_recursive() { | ||
1072 | check( | ||
1073 | r#" | ||
1074 | macro_rules! id_deep { ($($tt:tt)*) => { $($tt)* } } | ||
1075 | macro_rules! id { ($($tt:tt)*) => { id_deep!($($tt)*) } } | ||
1076 | fn foo(bar:u32) { let a = id!(ba<|>r); } | ||
1077 | "#, | ||
1078 | expect![[r#" | ||
1079 | *bar* | ||
1080 | |||
1081 | ```rust | ||
1082 | u32 | ||
1083 | ``` | ||
1084 | "#]], | ||
1085 | ); | ||
1086 | } | ||
1087 | |||
1088 | #[test] | ||
1089 | fn test_hover_through_func_in_macro_recursive() { | ||
1090 | check( | ||
1091 | r#" | ||
1092 | macro_rules! id_deep { ($($tt:tt)*) => { $($tt)* } } | ||
1093 | macro_rules! id { ($($tt:tt)*) => { id_deep!($($tt)*) } } | ||
1094 | fn bar() -> u32 { 0 } | ||
1095 | fn foo() { let a = id!([0u32, bar(<|>)] ); } | ||
1096 | "#, | ||
1097 | expect![[r#" | ||
1098 | *bar()* | ||
1099 | ```rust | ||
1100 | u32 | ||
1101 | ``` | ||
1102 | "#]], | ||
1103 | ); | ||
1104 | } | ||
1105 | |||
1106 | #[test] | ||
1107 | fn test_hover_through_literal_string_in_macro() { | ||
1108 | check( | ||
1109 | r#" | ||
1110 | macro_rules! arr { ($($tt:tt)*) => { [$($tt)*)] } } | ||
1111 | fn foo() { | ||
1112 | let mastered_for_itunes = ""; | ||
1113 | let _ = arr!("Tr<|>acks", &mastered_for_itunes); | ||
1114 | } | ||
1115 | "#, | ||
1116 | expect![[r#" | ||
1117 | *"Tracks"* | ||
1118 | ```rust | ||
1119 | &str | ||
1120 | ``` | ||
1121 | "#]], | ||
1122 | ); | ||
1123 | } | ||
1124 | |||
1125 | #[test] | ||
1126 | fn test_hover_through_assert_macro() { | ||
1127 | check( | ||
1128 | r#" | ||
1129 | #[rustc_builtin_macro] | ||
1130 | macro_rules! assert {} | ||
1131 | |||
1132 | fn bar() -> bool { true } | ||
1133 | fn foo() { | ||
1134 | assert!(ba<|>r()); | ||
1135 | } | ||
1136 | "#, | ||
1137 | expect![[r#" | ||
1138 | *bar* | ||
1139 | |||
1140 | ```rust | ||
1141 | test | ||
1142 | ``` | ||
1143 | |||
1144 | ```rust | ||
1145 | fn bar() -> bool | ||
1146 | ``` | ||
1147 | "#]], | ||
1148 | ); | ||
1149 | } | ||
1150 | |||
1151 | #[test] | ||
1152 | fn test_hover_through_literal_string_in_builtin_macro() { | ||
1153 | check_hover_no_result( | ||
1154 | r#" | ||
1155 | #[rustc_builtin_macro] | ||
1156 | macro_rules! format {} | ||
1157 | |||
1158 | fn foo() { | ||
1159 | format!("hel<|>lo {}", 0); | ||
1160 | } | ||
1161 | "#, | ||
1162 | ); | ||
1163 | } | ||
1164 | |||
1165 | #[test] | ||
1166 | fn test_hover_non_ascii_space_doc() { | ||
1167 | check( | ||
1168 | " | ||
1169 | /// <- `\u{3000}` here | ||
1170 | fn foo() { } | ||
1171 | |||
1172 | fn bar() { fo<|>o(); } | ||
1173 | ", | ||
1174 | expect![[r#" | ||
1175 | *foo* | ||
1176 | |||
1177 | ```rust | ||
1178 | test | ||
1179 | ``` | ||
1180 | |||
1181 | ```rust | ||
1182 | fn foo() | ||
1183 | ``` | ||
1184 | |||
1185 | --- | ||
1186 | |||
1187 | \<- ` ` here | ||
1188 | "#]], | ||
1189 | ); | ||
1190 | } | ||
1191 | |||
1192 | #[test] | ||
1193 | fn test_hover_function_show_qualifiers() { | ||
1194 | check( | ||
1195 | r#"async fn foo<|>() {}"#, | ||
1196 | expect![[r#" | ||
1197 | *foo* | ||
1198 | |||
1199 | ```rust | ||
1200 | test | ||
1201 | ``` | ||
1202 | |||
1203 | ```rust | ||
1204 | async fn foo() | ||
1205 | ``` | ||
1206 | "#]], | ||
1207 | ); | ||
1208 | check( | ||
1209 | r#"pub const unsafe fn foo<|>() {}"#, | ||
1210 | expect![[r#" | ||
1211 | *foo* | ||
1212 | |||
1213 | ```rust | ||
1214 | test | ||
1215 | ``` | ||
1216 | |||
1217 | ```rust | ||
1218 | pub const unsafe fn foo() | ||
1219 | ``` | ||
1220 | "#]], | ||
1221 | ); | ||
1222 | check( | ||
1223 | r#"pub(crate) async unsafe extern "C" fn foo<|>() {}"#, | ||
1224 | expect![[r#" | ||
1225 | *foo* | ||
1226 | |||
1227 | ```rust | ||
1228 | test | ||
1229 | ``` | ||
1230 | |||
1231 | ```rust | ||
1232 | pub(crate) async unsafe extern "C" fn foo() | ||
1233 | ``` | ||
1234 | "#]], | ||
1235 | ); | ||
1236 | } | ||
1237 | |||
1238 | #[test] | ||
1239 | fn test_hover_trait_show_qualifiers() { | ||
1240 | check_actions( | ||
1241 | r"unsafe trait foo<|>() {}", | ||
1242 | expect![[r#" | ||
1243 | [ | ||
1244 | Implementaion( | ||
1245 | FilePosition { | ||
1246 | file_id: FileId( | ||
1247 | 1, | ||
1248 | ), | ||
1249 | offset: 13, | ||
1250 | }, | ||
1251 | ), | ||
1252 | ] | ||
1253 | "#]], | ||
1254 | ); | ||
1255 | } | ||
1256 | |||
1257 | #[test] | ||
1258 | fn test_hover_extern_crate() { | ||
1259 | check( | ||
1260 | r#" | ||
1261 | //- /main.rs | ||
1262 | extern crate st<|>d; | ||
1263 | //- /std/lib.rs | ||
1264 | //! Standard library for this test | ||
1265 | //! | ||
1266 | //! Printed? | ||
1267 | //! abc123 | ||
1268 | "#, | ||
1269 | expect![[r#" | ||
1270 | *std* | ||
1271 | Standard library for this test | ||
1272 | |||
1273 | Printed? | ||
1274 | abc123 | ||
1275 | "#]], | ||
1276 | ); | ||
1277 | check( | ||
1278 | r#" | ||
1279 | //- /main.rs | ||
1280 | extern crate std as ab<|>c; | ||
1281 | //- /std/lib.rs | ||
1282 | //! Standard library for this test | ||
1283 | //! | ||
1284 | //! Printed? | ||
1285 | //! abc123 | ||
1286 | "#, | ||
1287 | expect![[r#" | ||
1288 | *abc* | ||
1289 | Standard library for this test | ||
1290 | |||
1291 | Printed? | ||
1292 | abc123 | ||
1293 | "#]], | ||
1294 | ); | ||
1295 | } | ||
1296 | |||
1297 | #[test] | ||
1298 | fn test_hover_mod_with_same_name_as_function() { | ||
1299 | check( | ||
1300 | r#" | ||
1301 | use self::m<|>y::Bar; | ||
1302 | mod my { pub struct Bar; } | ||
1303 | |||
1304 | fn my() {} | ||
1305 | "#, | ||
1306 | expect![[r#" | ||
1307 | *my* | ||
1308 | |||
1309 | ```rust | ||
1310 | test | ||
1311 | ``` | ||
1312 | |||
1313 | ```rust | ||
1314 | mod my | ||
1315 | ``` | ||
1316 | "#]], | ||
1317 | ); | ||
1318 | } | ||
1319 | |||
1320 | #[test] | ||
1321 | fn test_hover_struct_doc_comment() { | ||
1322 | check( | ||
1323 | r#" | ||
1324 | /// bar docs | ||
1325 | struct Bar; | ||
1326 | |||
1327 | fn foo() { let bar = Ba<|>r; } | ||
1328 | "#, | ||
1329 | expect![[r#" | ||
1330 | *Bar* | ||
1331 | |||
1332 | ```rust | ||
1333 | test | ||
1334 | ``` | ||
1335 | |||
1336 | ```rust | ||
1337 | struct Bar | ||
1338 | ``` | ||
1339 | |||
1340 | --- | ||
1341 | |||
1342 | bar docs | ||
1343 | "#]], | ||
1344 | ); | ||
1345 | } | ||
1346 | |||
1347 | #[test] | ||
1348 | fn test_hover_struct_doc_attr() { | ||
1349 | check( | ||
1350 | r#" | ||
1351 | #[doc = "bar docs"] | ||
1352 | struct Bar; | ||
1353 | |||
1354 | fn foo() { let bar = Ba<|>r; } | ||
1355 | "#, | ||
1356 | expect![[r#" | ||
1357 | *Bar* | ||
1358 | |||
1359 | ```rust | ||
1360 | test | ||
1361 | ``` | ||
1362 | |||
1363 | ```rust | ||
1364 | struct Bar | ||
1365 | ``` | ||
1366 | |||
1367 | --- | ||
1368 | |||
1369 | bar docs | ||
1370 | "#]], | ||
1371 | ); | ||
1372 | } | ||
1373 | |||
1374 | #[test] | ||
1375 | fn test_hover_struct_doc_attr_multiple_and_mixed() { | ||
1376 | check( | ||
1377 | r#" | ||
1378 | /// bar docs 0 | ||
1379 | #[doc = "bar docs 1"] | ||
1380 | #[doc = "bar docs 2"] | ||
1381 | struct Bar; | ||
1382 | |||
1383 | fn foo() { let bar = Ba<|>r; } | ||
1384 | "#, | ||
1385 | expect![[r#" | ||
1386 | *Bar* | ||
1387 | |||
1388 | ```rust | ||
1389 | test | ||
1390 | ``` | ||
1391 | |||
1392 | ```rust | ||
1393 | struct Bar | ||
1394 | ``` | ||
1395 | |||
1396 | --- | ||
1397 | |||
1398 | bar docs 0 | ||
1399 | |||
1400 | bar docs 1 | ||
1401 | |||
1402 | bar docs 2 | ||
1403 | "#]], | ||
1404 | ); | ||
1405 | } | ||
1406 | |||
1407 | #[test] | ||
1408 | fn test_hover_path_link() { | ||
1409 | check( | ||
1410 | r" | ||
1411 | //- /lib.rs | ||
1412 | pub struct Foo; | ||
1413 | /// [Foo](struct.Foo.html) | ||
1414 | pub struct B<|>ar | ||
1415 | ", | ||
1416 | expect![[r#" | ||
1417 | *Bar* | ||
1418 | |||
1419 | ```rust | ||
1420 | test | ||
1421 | ``` | ||
1422 | |||
1423 | ```rust | ||
1424 | pub struct Bar | ||
1425 | ``` | ||
1426 | |||
1427 | --- | ||
1428 | |||
1429 | [Foo](https://docs.rs/test/*/test/struct.Foo.html) | ||
1430 | "#]], | ||
1431 | ); | ||
1432 | } | ||
1433 | |||
1434 | #[test] | ||
1435 | fn test_hover_path_link_no_strip() { | ||
1436 | check( | ||
1437 | r" | ||
1438 | //- /lib.rs | ||
1439 | pub struct Foo; | ||
1440 | /// [struct Foo](struct.Foo.html) | ||
1441 | pub struct B<|>ar | ||
1442 | ", | ||
1443 | expect![[r#" | ||
1444 | *Bar* | ||
1445 | |||
1446 | ```rust | ||
1447 | test | ||
1448 | ``` | ||
1449 | |||
1450 | ```rust | ||
1451 | pub struct Bar | ||
1452 | ``` | ||
1453 | |||
1454 | --- | ||
1455 | |||
1456 | [struct Foo](https://docs.rs/test/*/test/struct.Foo.html) | ||
1457 | "#]], | ||
1458 | ); | ||
1459 | } | ||
1460 | |||
1461 | #[ignore = "path based links currently only support documentation on ModuleDef items"] | ||
1462 | #[test] | ||
1463 | fn test_hover_path_link_field() { | ||
1464 | check( | ||
1465 | r" | ||
1466 | //- /lib.rs | ||
1467 | pub struct Foo; | ||
1468 | pub struct Bar { | ||
1469 | /// [Foo](struct.Foo.html) | ||
1470 | fie<|>ld: () | ||
1471 | } | ||
1472 | ", | ||
1473 | expect![[r#" | ||
1474 | *field* | ||
1475 | |||
1476 | ```rust | ||
1477 | test::Bar | ||
1478 | ``` | ||
1479 | |||
1480 | ```rust | ||
1481 | field: () | ||
1482 | ``` | ||
1483 | |||
1484 | --- | ||
1485 | |||
1486 | [Foo](https://docs.rs/test/*/test/struct.Foo.html) | ||
1487 | "#]], | ||
1488 | ); | ||
1489 | } | ||
1490 | |||
1491 | #[test] | ||
1492 | fn test_hover_intra_link() { | ||
1493 | check( | ||
1494 | r" | ||
1495 | //- /lib.rs | ||
1496 | pub mod foo { | ||
1497 | pub struct Foo; | ||
1498 | } | ||
1499 | /// [Foo](foo::Foo) | ||
1500 | pub struct B<|>ar | ||
1501 | ", | ||
1502 | expect![[r#" | ||
1503 | *Bar* | ||
1504 | |||
1505 | ```rust | ||
1506 | test | ||
1507 | ``` | ||
1508 | |||
1509 | ```rust | ||
1510 | pub struct Bar | ||
1511 | ``` | ||
1512 | |||
1513 | --- | ||
1514 | |||
1515 | [Foo](https://docs.rs/test/*/test/foo/struct.Foo.html) | ||
1516 | "#]], | ||
1517 | ); | ||
1518 | } | ||
1519 | |||
1520 | #[test] | ||
1521 | fn test_hover_intra_link_html_root_url() { | ||
1522 | check( | ||
1523 | r#" | ||
1524 | //- /lib.rs | ||
1525 | |||
1526 | #![doc(arbitrary_attribute = "test", html_root_url = "https:/example.com", arbitrary_attribute2)] | ||
1527 | |||
1528 | pub mod foo { | ||
1529 | pub struct Foo; | ||
1530 | } | ||
1531 | /// [Foo](foo::Foo) | ||
1532 | pub struct B<|>ar | ||
1533 | "#, | ||
1534 | expect![[r#" | ||
1535 | *Bar* | ||
1536 | |||
1537 | ```rust | ||
1538 | test | ||
1539 | ``` | ||
1540 | |||
1541 | ```rust | ||
1542 | pub struct Bar | ||
1543 | ``` | ||
1544 | |||
1545 | --- | ||
1546 | |||
1547 | [Foo](https://example.com/test/foo/struct.Foo.html) | ||
1548 | "#]], | ||
1549 | ); | ||
1550 | } | ||
1551 | |||
1552 | #[test] | ||
1553 | fn test_hover_intra_link_shortlink() { | ||
1554 | check( | ||
1555 | r" | ||
1556 | //- /lib.rs | ||
1557 | pub struct Foo; | ||
1558 | /// [Foo] | ||
1559 | pub struct B<|>ar | ||
1560 | ", | ||
1561 | expect![[r#" | ||
1562 | *Bar* | ||
1563 | |||
1564 | ```rust | ||
1565 | test | ||
1566 | ``` | ||
1567 | |||
1568 | ```rust | ||
1569 | pub struct Bar | ||
1570 | ``` | ||
1571 | |||
1572 | --- | ||
1573 | |||
1574 | [Foo](https://docs.rs/test/*/test/struct.Foo.html) | ||
1575 | "#]], | ||
1576 | ); | ||
1577 | } | ||
1578 | |||
1579 | #[test] | ||
1580 | fn test_hover_intra_link_shortlink_code() { | ||
1581 | check( | ||
1582 | r" | ||
1583 | //- /lib.rs | ||
1584 | pub struct Foo; | ||
1585 | /// [`Foo`] | ||
1586 | pub struct B<|>ar | ||
1587 | ", | ||
1588 | expect![[r#" | ||
1589 | *Bar* | ||
1590 | |||
1591 | ```rust | ||
1592 | test | ||
1593 | ``` | ||
1594 | |||
1595 | ```rust | ||
1596 | pub struct Bar | ||
1597 | ``` | ||
1598 | |||
1599 | --- | ||
1600 | |||
1601 | [`Foo`](https://docs.rs/test/*/test/struct.Foo.html) | ||
1602 | "#]], | ||
1603 | ); | ||
1604 | } | ||
1605 | |||
1606 | #[test] | ||
1607 | fn test_hover_intra_link_namespaced() { | ||
1608 | check( | ||
1609 | r" | ||
1610 | //- /lib.rs | ||
1611 | pub struct Foo; | ||
1612 | fn Foo() {} | ||
1613 | /// [Foo()] | ||
1614 | pub struct B<|>ar | ||
1615 | ", | ||
1616 | expect![[r#" | ||
1617 | *Bar* | ||
1618 | |||
1619 | ```rust | ||
1620 | test | ||
1621 | ``` | ||
1622 | |||
1623 | ```rust | ||
1624 | pub struct Bar | ||
1625 | ``` | ||
1626 | |||
1627 | --- | ||
1628 | |||
1629 | [Foo](https://docs.rs/test/*/test/struct.Foo.html) | ||
1630 | "#]], | ||
1631 | ); | ||
1632 | } | ||
1633 | |||
1634 | #[test] | ||
1635 | fn test_hover_intra_link_shortlink_namspaced_code() { | ||
1636 | check( | ||
1637 | r" | ||
1638 | //- /lib.rs | ||
1639 | pub struct Foo; | ||
1640 | /// [`struct Foo`] | ||
1641 | pub struct B<|>ar | ||
1642 | ", | ||
1643 | expect![[r#" | ||
1644 | *Bar* | ||
1645 | |||
1646 | ```rust | ||
1647 | test | ||
1648 | ``` | ||
1649 | |||
1650 | ```rust | ||
1651 | pub struct Bar | ||
1652 | ``` | ||
1653 | |||
1654 | --- | ||
1655 | |||
1656 | [`Foo`](https://docs.rs/test/*/test/struct.Foo.html) | ||
1657 | "#]], | ||
1658 | ); | ||
1659 | } | ||
1660 | |||
1661 | #[test] | ||
1662 | fn test_hover_intra_link_shortlink_namspaced_code_with_at() { | ||
1663 | check( | ||
1664 | r" | ||
1665 | //- /lib.rs | ||
1666 | pub struct Foo; | ||
1667 | /// [`struct@Foo`] | ||
1668 | pub struct B<|>ar | ||
1669 | ", | ||
1670 | expect![[r#" | ||
1671 | *Bar* | ||
1672 | |||
1673 | ```rust | ||
1674 | test | ||
1675 | ``` | ||
1676 | |||
1677 | ```rust | ||
1678 | pub struct Bar | ||
1679 | ``` | ||
1680 | |||
1681 | --- | ||
1682 | |||
1683 | [`Foo`](https://docs.rs/test/*/test/struct.Foo.html) | ||
1684 | "#]], | ||
1685 | ); | ||
1686 | } | ||
1687 | |||
1688 | #[test] | ||
1689 | fn test_hover_intra_link_reference() { | ||
1690 | check( | ||
1691 | r" | ||
1692 | //- /lib.rs | ||
1693 | pub struct Foo; | ||
1694 | /// [my Foo][foo] | ||
1695 | /// | ||
1696 | /// [foo]: Foo | ||
1697 | pub struct B<|>ar | ||
1698 | ", | ||
1699 | expect![[r#" | ||
1700 | *Bar* | ||
1701 | |||
1702 | ```rust | ||
1703 | test | ||
1704 | ``` | ||
1705 | |||
1706 | ```rust | ||
1707 | pub struct Bar | ||
1708 | ``` | ||
1709 | |||
1710 | --- | ||
1711 | |||
1712 | [my Foo](https://docs.rs/test/*/test/struct.Foo.html) | ||
1713 | "#]], | ||
1714 | ); | ||
1715 | } | ||
1716 | |||
1717 | #[test] | ||
1718 | fn test_hover_external_url() { | ||
1719 | check( | ||
1720 | r" | ||
1721 | //- /lib.rs | ||
1722 | pub struct Foo; | ||
1723 | /// [external](https://www.google.com) | ||
1724 | pub struct B<|>ar | ||
1725 | ", | ||
1726 | expect![[r#" | ||
1727 | *Bar* | ||
1728 | |||
1729 | ```rust | ||
1730 | test | ||
1731 | ``` | ||
1732 | |||
1733 | ```rust | ||
1734 | pub struct Bar | ||
1735 | ``` | ||
1736 | |||
1737 | --- | ||
1738 | |||
1739 | [external](https://www.google.com) | ||
1740 | "#]], | ||
1741 | ); | ||
1742 | } | ||
1743 | |||
1744 | // Check that we don't rewrite links which we can't identify | ||
1745 | #[test] | ||
1746 | fn test_hover_unknown_target() { | ||
1747 | check( | ||
1748 | r" | ||
1749 | //- /lib.rs | ||
1750 | pub struct Foo; | ||
1751 | /// [baz](Baz) | ||
1752 | pub struct B<|>ar | ||
1753 | ", | ||
1754 | expect![[r#" | ||
1755 | *Bar* | ||
1756 | |||
1757 | ```rust | ||
1758 | test | ||
1759 | ``` | ||
1760 | |||
1761 | ```rust | ||
1762 | pub struct Bar | ||
1763 | ``` | ||
1764 | |||
1765 | --- | ||
1766 | |||
1767 | [baz](Baz) | ||
1768 | "#]], | ||
1769 | ); | ||
1770 | } | ||
1771 | |||
1772 | #[test] | ||
1773 | fn test_hover_macro_generated_struct_fn_doc_comment() { | ||
1774 | mark::check!(hover_macro_generated_struct_fn_doc_comment); | ||
1775 | |||
1776 | check( | ||
1777 | r#" | ||
1778 | macro_rules! bar { | ||
1779 | () => { | ||
1780 | struct Bar; | ||
1781 | impl Bar { | ||
1782 | /// Do the foo | ||
1783 | fn foo(&self) {} | ||
1784 | } | ||
1785 | } | ||
1786 | } | ||
1787 | |||
1788 | bar!(); | ||
1789 | |||
1790 | fn foo() { let bar = Bar; bar.fo<|>o(); } | ||
1791 | "#, | ||
1792 | expect![[r#" | ||
1793 | *foo* | ||
1794 | |||
1795 | ```rust | ||
1796 | test::Bar | ||
1797 | ``` | ||
1798 | |||
1799 | ```rust | ||
1800 | fn foo(&self) | ||
1801 | ``` | ||
1802 | |||
1803 | --- | ||
1804 | |||
1805 | Do the foo | ||
1806 | "#]], | ||
1807 | ); | ||
1808 | } | ||
1809 | |||
1810 | #[test] | ||
1811 | fn test_hover_macro_generated_struct_fn_doc_attr() { | ||
1812 | mark::check!(hover_macro_generated_struct_fn_doc_attr); | ||
1813 | |||
1814 | check( | ||
1815 | r#" | ||
1816 | macro_rules! bar { | ||
1817 | () => { | ||
1818 | struct Bar; | ||
1819 | impl Bar { | ||
1820 | #[doc = "Do the foo"] | ||
1821 | fn foo(&self) {} | ||
1822 | } | ||
1823 | } | ||
1824 | } | ||
1825 | |||
1826 | bar!(); | ||
1827 | |||
1828 | fn foo() { let bar = Bar; bar.fo<|>o(); } | ||
1829 | "#, | ||
1830 | expect![[r#" | ||
1831 | *foo* | ||
1832 | |||
1833 | ```rust | ||
1834 | test::Bar | ||
1835 | ``` | ||
1836 | |||
1837 | ```rust | ||
1838 | fn foo(&self) | ||
1839 | ``` | ||
1840 | |||
1841 | --- | ||
1842 | |||
1843 | Do the foo | ||
1844 | "#]], | ||
1845 | ); | ||
1846 | } | ||
1847 | |||
1848 | #[test] | ||
1849 | fn test_hover_trait_has_impl_action() { | ||
1850 | check_actions( | ||
1851 | r#"trait foo<|>() {}"#, | ||
1852 | expect![[r#" | ||
1853 | [ | ||
1854 | Implementaion( | ||
1855 | FilePosition { | ||
1856 | file_id: FileId( | ||
1857 | 1, | ||
1858 | ), | ||
1859 | offset: 6, | ||
1860 | }, | ||
1861 | ), | ||
1862 | ] | ||
1863 | "#]], | ||
1864 | ); | ||
1865 | } | ||
1866 | |||
1867 | #[test] | ||
1868 | fn test_hover_struct_has_impl_action() { | ||
1869 | check_actions( | ||
1870 | r"struct foo<|>() {}", | ||
1871 | expect![[r#" | ||
1872 | [ | ||
1873 | Implementaion( | ||
1874 | FilePosition { | ||
1875 | file_id: FileId( | ||
1876 | 1, | ||
1877 | ), | ||
1878 | offset: 7, | ||
1879 | }, | ||
1880 | ), | ||
1881 | ] | ||
1882 | "#]], | ||
1883 | ); | ||
1884 | } | ||
1885 | |||
1886 | #[test] | ||
1887 | fn test_hover_union_has_impl_action() { | ||
1888 | check_actions( | ||
1889 | r#"union foo<|>() {}"#, | ||
1890 | expect![[r#" | ||
1891 | [ | ||
1892 | Implementaion( | ||
1893 | FilePosition { | ||
1894 | file_id: FileId( | ||
1895 | 1, | ||
1896 | ), | ||
1897 | offset: 6, | ||
1898 | }, | ||
1899 | ), | ||
1900 | ] | ||
1901 | "#]], | ||
1902 | ); | ||
1903 | } | ||
1904 | |||
1905 | #[test] | ||
1906 | fn test_hover_enum_has_impl_action() { | ||
1907 | check_actions( | ||
1908 | r"enum foo<|>() { A, B }", | ||
1909 | expect![[r#" | ||
1910 | [ | ||
1911 | Implementaion( | ||
1912 | FilePosition { | ||
1913 | file_id: FileId( | ||
1914 | 1, | ||
1915 | ), | ||
1916 | offset: 5, | ||
1917 | }, | ||
1918 | ), | ||
1919 | ] | ||
1920 | "#]], | ||
1921 | ); | ||
1922 | } | ||
1923 | |||
1924 | #[test] | ||
1925 | fn test_hover_test_has_action() { | ||
1926 | check_actions( | ||
1927 | r#" | ||
1928 | #[test] | ||
1929 | fn foo_<|>test() {} | ||
1930 | "#, | ||
1931 | expect![[r#" | ||
1932 | [ | ||
1933 | Runnable( | ||
1934 | Runnable { | ||
1935 | nav: NavigationTarget { | ||
1936 | file_id: FileId( | ||
1937 | 1, | ||
1938 | ), | ||
1939 | full_range: 0..24, | ||
1940 | focus_range: Some( | ||
1941 | 11..19, | ||
1942 | ), | ||
1943 | name: "foo_test", | ||
1944 | kind: FN, | ||
1945 | container_name: None, | ||
1946 | description: None, | ||
1947 | docs: None, | ||
1948 | }, | ||
1949 | kind: Test { | ||
1950 | test_id: Path( | ||
1951 | "foo_test", | ||
1952 | ), | ||
1953 | attr: TestAttr { | ||
1954 | ignore: false, | ||
1955 | }, | ||
1956 | }, | ||
1957 | cfg_exprs: [], | ||
1958 | }, | ||
1959 | ), | ||
1960 | ] | ||
1961 | "#]], | ||
1962 | ); | ||
1963 | } | ||
1964 | |||
1965 | #[test] | ||
1966 | fn test_hover_test_mod_has_action() { | ||
1967 | check_actions( | ||
1968 | r#" | ||
1969 | mod tests<|> { | ||
1970 | #[test] | ||
1971 | fn foo_test() {} | ||
1972 | } | ||
1973 | "#, | ||
1974 | expect![[r#" | ||
1975 | [ | ||
1976 | Runnable( | ||
1977 | Runnable { | ||
1978 | nav: NavigationTarget { | ||
1979 | file_id: FileId( | ||
1980 | 1, | ||
1981 | ), | ||
1982 | full_range: 0..46, | ||
1983 | focus_range: Some( | ||
1984 | 4..9, | ||
1985 | ), | ||
1986 | name: "tests", | ||
1987 | kind: MODULE, | ||
1988 | container_name: None, | ||
1989 | description: None, | ||
1990 | docs: None, | ||
1991 | }, | ||
1992 | kind: TestMod { | ||
1993 | path: "tests", | ||
1994 | }, | ||
1995 | cfg_exprs: [], | ||
1996 | }, | ||
1997 | ), | ||
1998 | ] | ||
1999 | "#]], | ||
2000 | ); | ||
2001 | } | ||
2002 | |||
2003 | #[test] | ||
2004 | fn test_hover_struct_has_goto_type_action() { | ||
2005 | check_actions( | ||
2006 | r#" | ||
2007 | struct S{ f1: u32 } | ||
2008 | |||
2009 | fn main() { let s<|>t = S{ f1:0 }; } | ||
2010 | "#, | ||
2011 | expect![[r#" | ||
2012 | [ | ||
2013 | GoToType( | ||
2014 | [ | ||
2015 | HoverGotoTypeData { | ||
2016 | mod_path: "test::S", | ||
2017 | nav: NavigationTarget { | ||
2018 | file_id: FileId( | ||
2019 | 1, | ||
2020 | ), | ||
2021 | full_range: 0..19, | ||
2022 | focus_range: Some( | ||
2023 | 7..8, | ||
2024 | ), | ||
2025 | name: "S", | ||
2026 | kind: STRUCT, | ||
2027 | container_name: None, | ||
2028 | description: Some( | ||
2029 | "struct S", | ||
2030 | ), | ||
2031 | docs: None, | ||
2032 | }, | ||
2033 | }, | ||
2034 | ], | ||
2035 | ), | ||
2036 | ] | ||
2037 | "#]], | ||
2038 | ); | ||
2039 | } | ||
2040 | |||
2041 | #[test] | ||
2042 | fn test_hover_generic_struct_has_goto_type_actions() { | ||
2043 | check_actions( | ||
2044 | r#" | ||
2045 | struct Arg(u32); | ||
2046 | struct S<T>{ f1: T } | ||
2047 | |||
2048 | fn main() { let s<|>t = S{ f1:Arg(0) }; } | ||
2049 | "#, | ||
2050 | expect![[r#" | ||
2051 | [ | ||
2052 | GoToType( | ||
2053 | [ | ||
2054 | HoverGotoTypeData { | ||
2055 | mod_path: "test::S", | ||
2056 | nav: NavigationTarget { | ||
2057 | file_id: FileId( | ||
2058 | 1, | ||
2059 | ), | ||
2060 | full_range: 17..37, | ||
2061 | focus_range: Some( | ||
2062 | 24..25, | ||
2063 | ), | ||
2064 | name: "S", | ||
2065 | kind: STRUCT, | ||
2066 | container_name: None, | ||
2067 | description: Some( | ||
2068 | "struct S", | ||
2069 | ), | ||
2070 | docs: None, | ||
2071 | }, | ||
2072 | }, | ||
2073 | HoverGotoTypeData { | ||
2074 | mod_path: "test::Arg", | ||
2075 | nav: NavigationTarget { | ||
2076 | file_id: FileId( | ||
2077 | 1, | ||
2078 | ), | ||
2079 | full_range: 0..16, | ||
2080 | focus_range: Some( | ||
2081 | 7..10, | ||
2082 | ), | ||
2083 | name: "Arg", | ||
2084 | kind: STRUCT, | ||
2085 | container_name: None, | ||
2086 | description: Some( | ||
2087 | "struct Arg", | ||
2088 | ), | ||
2089 | docs: None, | ||
2090 | }, | ||
2091 | }, | ||
2092 | ], | ||
2093 | ), | ||
2094 | ] | ||
2095 | "#]], | ||
2096 | ); | ||
2097 | } | ||
2098 | |||
2099 | #[test] | ||
2100 | fn test_hover_generic_struct_has_flattened_goto_type_actions() { | ||
2101 | check_actions( | ||
2102 | r#" | ||
2103 | struct Arg(u32); | ||
2104 | struct S<T>{ f1: T } | ||
2105 | |||
2106 | fn main() { let s<|>t = S{ f1: S{ f1: Arg(0) } }; } | ||
2107 | "#, | ||
2108 | expect![[r#" | ||
2109 | [ | ||
2110 | GoToType( | ||
2111 | [ | ||
2112 | HoverGotoTypeData { | ||
2113 | mod_path: "test::S", | ||
2114 | nav: NavigationTarget { | ||
2115 | file_id: FileId( | ||
2116 | 1, | ||
2117 | ), | ||
2118 | full_range: 17..37, | ||
2119 | focus_range: Some( | ||
2120 | 24..25, | ||
2121 | ), | ||
2122 | name: "S", | ||
2123 | kind: STRUCT, | ||
2124 | container_name: None, | ||
2125 | description: Some( | ||
2126 | "struct S", | ||
2127 | ), | ||
2128 | docs: None, | ||
2129 | }, | ||
2130 | }, | ||
2131 | HoverGotoTypeData { | ||
2132 | mod_path: "test::Arg", | ||
2133 | nav: NavigationTarget { | ||
2134 | file_id: FileId( | ||
2135 | 1, | ||
2136 | ), | ||
2137 | full_range: 0..16, | ||
2138 | focus_range: Some( | ||
2139 | 7..10, | ||
2140 | ), | ||
2141 | name: "Arg", | ||
2142 | kind: STRUCT, | ||
2143 | container_name: None, | ||
2144 | description: Some( | ||
2145 | "struct Arg", | ||
2146 | ), | ||
2147 | docs: None, | ||
2148 | }, | ||
2149 | }, | ||
2150 | ], | ||
2151 | ), | ||
2152 | ] | ||
2153 | "#]], | ||
2154 | ); | ||
2155 | } | ||
2156 | |||
2157 | #[test] | ||
2158 | fn test_hover_tuple_has_goto_type_actions() { | ||
2159 | check_actions( | ||
2160 | r#" | ||
2161 | struct A(u32); | ||
2162 | struct B(u32); | ||
2163 | mod M { | ||
2164 | pub struct C(u32); | ||
2165 | } | ||
2166 | |||
2167 | fn main() { let s<|>t = (A(1), B(2), M::C(3) ); } | ||
2168 | "#, | ||
2169 | expect![[r#" | ||
2170 | [ | ||
2171 | GoToType( | ||
2172 | [ | ||
2173 | HoverGotoTypeData { | ||
2174 | mod_path: "test::A", | ||
2175 | nav: NavigationTarget { | ||
2176 | file_id: FileId( | ||
2177 | 1, | ||
2178 | ), | ||
2179 | full_range: 0..14, | ||
2180 | focus_range: Some( | ||
2181 | 7..8, | ||
2182 | ), | ||
2183 | name: "A", | ||
2184 | kind: STRUCT, | ||
2185 | container_name: None, | ||
2186 | description: Some( | ||
2187 | "struct A", | ||
2188 | ), | ||
2189 | docs: None, | ||
2190 | }, | ||
2191 | }, | ||
2192 | HoverGotoTypeData { | ||
2193 | mod_path: "test::B", | ||
2194 | nav: NavigationTarget { | ||
2195 | file_id: FileId( | ||
2196 | 1, | ||
2197 | ), | ||
2198 | full_range: 15..29, | ||
2199 | focus_range: Some( | ||
2200 | 22..23, | ||
2201 | ), | ||
2202 | name: "B", | ||
2203 | kind: STRUCT, | ||
2204 | container_name: None, | ||
2205 | description: Some( | ||
2206 | "struct B", | ||
2207 | ), | ||
2208 | docs: None, | ||
2209 | }, | ||
2210 | }, | ||
2211 | HoverGotoTypeData { | ||
2212 | mod_path: "test::M::C", | ||
2213 | nav: NavigationTarget { | ||
2214 | file_id: FileId( | ||
2215 | 1, | ||
2216 | ), | ||
2217 | full_range: 42..60, | ||
2218 | focus_range: Some( | ||
2219 | 53..54, | ||
2220 | ), | ||
2221 | name: "C", | ||
2222 | kind: STRUCT, | ||
2223 | container_name: None, | ||
2224 | description: Some( | ||
2225 | "pub struct C", | ||
2226 | ), | ||
2227 | docs: None, | ||
2228 | }, | ||
2229 | }, | ||
2230 | ], | ||
2231 | ), | ||
2232 | ] | ||
2233 | "#]], | ||
2234 | ); | ||
2235 | } | ||
2236 | |||
2237 | #[test] | ||
2238 | fn test_hover_return_impl_trait_has_goto_type_action() { | ||
2239 | check_actions( | ||
2240 | r#" | ||
2241 | trait Foo {} | ||
2242 | fn foo() -> impl Foo {} | ||
2243 | |||
2244 | fn main() { let s<|>t = foo(); } | ||
2245 | "#, | ||
2246 | expect![[r#" | ||
2247 | [ | ||
2248 | GoToType( | ||
2249 | [ | ||
2250 | HoverGotoTypeData { | ||
2251 | mod_path: "test::Foo", | ||
2252 | nav: NavigationTarget { | ||
2253 | file_id: FileId( | ||
2254 | 1, | ||
2255 | ), | ||
2256 | full_range: 0..12, | ||
2257 | focus_range: Some( | ||
2258 | 6..9, | ||
2259 | ), | ||
2260 | name: "Foo", | ||
2261 | kind: TRAIT, | ||
2262 | container_name: None, | ||
2263 | description: Some( | ||
2264 | "trait Foo", | ||
2265 | ), | ||
2266 | docs: None, | ||
2267 | }, | ||
2268 | }, | ||
2269 | ], | ||
2270 | ), | ||
2271 | ] | ||
2272 | "#]], | ||
2273 | ); | ||
2274 | } | ||
2275 | |||
2276 | #[test] | ||
2277 | fn test_hover_generic_return_impl_trait_has_goto_type_action() { | ||
2278 | check_actions( | ||
2279 | r#" | ||
2280 | trait Foo<T> {} | ||
2281 | struct S; | ||
2282 | fn foo() -> impl Foo<S> {} | ||
2283 | |||
2284 | fn main() { let s<|>t = foo(); } | ||
2285 | "#, | ||
2286 | expect![[r#" | ||
2287 | [ | ||
2288 | GoToType( | ||
2289 | [ | ||
2290 | HoverGotoTypeData { | ||
2291 | mod_path: "test::Foo", | ||
2292 | nav: NavigationTarget { | ||
2293 | file_id: FileId( | ||
2294 | 1, | ||
2295 | ), | ||
2296 | full_range: 0..15, | ||
2297 | focus_range: Some( | ||
2298 | 6..9, | ||
2299 | ), | ||
2300 | name: "Foo", | ||
2301 | kind: TRAIT, | ||
2302 | container_name: None, | ||
2303 | description: Some( | ||
2304 | "trait Foo", | ||
2305 | ), | ||
2306 | docs: None, | ||
2307 | }, | ||
2308 | }, | ||
2309 | HoverGotoTypeData { | ||
2310 | mod_path: "test::S", | ||
2311 | nav: NavigationTarget { | ||
2312 | file_id: FileId( | ||
2313 | 1, | ||
2314 | ), | ||
2315 | full_range: 16..25, | ||
2316 | focus_range: Some( | ||
2317 | 23..24, | ||
2318 | ), | ||
2319 | name: "S", | ||
2320 | kind: STRUCT, | ||
2321 | container_name: None, | ||
2322 | description: Some( | ||
2323 | "struct S", | ||
2324 | ), | ||
2325 | docs: None, | ||
2326 | }, | ||
2327 | }, | ||
2328 | ], | ||
2329 | ), | ||
2330 | ] | ||
2331 | "#]], | ||
2332 | ); | ||
2333 | } | ||
2334 | |||
2335 | #[test] | ||
2336 | fn test_hover_return_impl_traits_has_goto_type_action() { | ||
2337 | check_actions( | ||
2338 | r#" | ||
2339 | trait Foo {} | ||
2340 | trait Bar {} | ||
2341 | fn foo() -> impl Foo + Bar {} | ||
2342 | |||
2343 | fn main() { let s<|>t = foo(); } | ||
2344 | "#, | ||
2345 | expect![[r#" | ||
2346 | [ | ||
2347 | GoToType( | ||
2348 | [ | ||
2349 | HoverGotoTypeData { | ||
2350 | mod_path: "test::Foo", | ||
2351 | nav: NavigationTarget { | ||
2352 | file_id: FileId( | ||
2353 | 1, | ||
2354 | ), | ||
2355 | full_range: 0..12, | ||
2356 | focus_range: Some( | ||
2357 | 6..9, | ||
2358 | ), | ||
2359 | name: "Foo", | ||
2360 | kind: TRAIT, | ||
2361 | container_name: None, | ||
2362 | description: Some( | ||
2363 | "trait Foo", | ||
2364 | ), | ||
2365 | docs: None, | ||
2366 | }, | ||
2367 | }, | ||
2368 | HoverGotoTypeData { | ||
2369 | mod_path: "test::Bar", | ||
2370 | nav: NavigationTarget { | ||
2371 | file_id: FileId( | ||
2372 | 1, | ||
2373 | ), | ||
2374 | full_range: 13..25, | ||
2375 | focus_range: Some( | ||
2376 | 19..22, | ||
2377 | ), | ||
2378 | name: "Bar", | ||
2379 | kind: TRAIT, | ||
2380 | container_name: None, | ||
2381 | description: Some( | ||
2382 | "trait Bar", | ||
2383 | ), | ||
2384 | docs: None, | ||
2385 | }, | ||
2386 | }, | ||
2387 | ], | ||
2388 | ), | ||
2389 | ] | ||
2390 | "#]], | ||
2391 | ); | ||
2392 | } | ||
2393 | |||
2394 | #[test] | ||
2395 | fn test_hover_generic_return_impl_traits_has_goto_type_action() { | ||
2396 | check_actions( | ||
2397 | r#" | ||
2398 | trait Foo<T> {} | ||
2399 | trait Bar<T> {} | ||
2400 | struct S1 {} | ||
2401 | struct S2 {} | ||
2402 | |||
2403 | fn foo() -> impl Foo<S1> + Bar<S2> {} | ||
2404 | |||
2405 | fn main() { let s<|>t = foo(); } | ||
2406 | "#, | ||
2407 | expect![[r#" | ||
2408 | [ | ||
2409 | GoToType( | ||
2410 | [ | ||
2411 | HoverGotoTypeData { | ||
2412 | mod_path: "test::Foo", | ||
2413 | nav: NavigationTarget { | ||
2414 | file_id: FileId( | ||
2415 | 1, | ||
2416 | ), | ||
2417 | full_range: 0..15, | ||
2418 | focus_range: Some( | ||
2419 | 6..9, | ||
2420 | ), | ||
2421 | name: "Foo", | ||
2422 | kind: TRAIT, | ||
2423 | container_name: None, | ||
2424 | description: Some( | ||
2425 | "trait Foo", | ||
2426 | ), | ||
2427 | docs: None, | ||
2428 | }, | ||
2429 | }, | ||
2430 | HoverGotoTypeData { | ||
2431 | mod_path: "test::Bar", | ||
2432 | nav: NavigationTarget { | ||
2433 | file_id: FileId( | ||
2434 | 1, | ||
2435 | ), | ||
2436 | full_range: 16..31, | ||
2437 | focus_range: Some( | ||
2438 | 22..25, | ||
2439 | ), | ||
2440 | name: "Bar", | ||
2441 | kind: TRAIT, | ||
2442 | container_name: None, | ||
2443 | description: Some( | ||
2444 | "trait Bar", | ||
2445 | ), | ||
2446 | docs: None, | ||
2447 | }, | ||
2448 | }, | ||
2449 | HoverGotoTypeData { | ||
2450 | mod_path: "test::S1", | ||
2451 | nav: NavigationTarget { | ||
2452 | file_id: FileId( | ||
2453 | 1, | ||
2454 | ), | ||
2455 | full_range: 32..44, | ||
2456 | focus_range: Some( | ||
2457 | 39..41, | ||
2458 | ), | ||
2459 | name: "S1", | ||
2460 | kind: STRUCT, | ||
2461 | container_name: None, | ||
2462 | description: Some( | ||
2463 | "struct S1", | ||
2464 | ), | ||
2465 | docs: None, | ||
2466 | }, | ||
2467 | }, | ||
2468 | HoverGotoTypeData { | ||
2469 | mod_path: "test::S2", | ||
2470 | nav: NavigationTarget { | ||
2471 | file_id: FileId( | ||
2472 | 1, | ||
2473 | ), | ||
2474 | full_range: 45..57, | ||
2475 | focus_range: Some( | ||
2476 | 52..54, | ||
2477 | ), | ||
2478 | name: "S2", | ||
2479 | kind: STRUCT, | ||
2480 | container_name: None, | ||
2481 | description: Some( | ||
2482 | "struct S2", | ||
2483 | ), | ||
2484 | docs: None, | ||
2485 | }, | ||
2486 | }, | ||
2487 | ], | ||
2488 | ), | ||
2489 | ] | ||
2490 | "#]], | ||
2491 | ); | ||
2492 | } | ||
2493 | |||
2494 | #[test] | ||
2495 | fn test_hover_arg_impl_trait_has_goto_type_action() { | ||
2496 | check_actions( | ||
2497 | r#" | ||
2498 | trait Foo {} | ||
2499 | fn foo(ar<|>g: &impl Foo) {} | ||
2500 | "#, | ||
2501 | expect![[r#" | ||
2502 | [ | ||
2503 | GoToType( | ||
2504 | [ | ||
2505 | HoverGotoTypeData { | ||
2506 | mod_path: "test::Foo", | ||
2507 | nav: NavigationTarget { | ||
2508 | file_id: FileId( | ||
2509 | 1, | ||
2510 | ), | ||
2511 | full_range: 0..12, | ||
2512 | focus_range: Some( | ||
2513 | 6..9, | ||
2514 | ), | ||
2515 | name: "Foo", | ||
2516 | kind: TRAIT, | ||
2517 | container_name: None, | ||
2518 | description: Some( | ||
2519 | "trait Foo", | ||
2520 | ), | ||
2521 | docs: None, | ||
2522 | }, | ||
2523 | }, | ||
2524 | ], | ||
2525 | ), | ||
2526 | ] | ||
2527 | "#]], | ||
2528 | ); | ||
2529 | } | ||
2530 | |||
2531 | #[test] | ||
2532 | fn test_hover_arg_impl_traits_has_goto_type_action() { | ||
2533 | check_actions( | ||
2534 | r#" | ||
2535 | trait Foo {} | ||
2536 | trait Bar<T> {} | ||
2537 | struct S{} | ||
2538 | |||
2539 | fn foo(ar<|>g: &impl Foo + Bar<S>) {} | ||
2540 | "#, | ||
2541 | expect![[r#" | ||
2542 | [ | ||
2543 | GoToType( | ||
2544 | [ | ||
2545 | HoverGotoTypeData { | ||
2546 | mod_path: "test::Foo", | ||
2547 | nav: NavigationTarget { | ||
2548 | file_id: FileId( | ||
2549 | 1, | ||
2550 | ), | ||
2551 | full_range: 0..12, | ||
2552 | focus_range: Some( | ||
2553 | 6..9, | ||
2554 | ), | ||
2555 | name: "Foo", | ||
2556 | kind: TRAIT, | ||
2557 | container_name: None, | ||
2558 | description: Some( | ||
2559 | "trait Foo", | ||
2560 | ), | ||
2561 | docs: None, | ||
2562 | }, | ||
2563 | }, | ||
2564 | HoverGotoTypeData { | ||
2565 | mod_path: "test::Bar", | ||
2566 | nav: NavigationTarget { | ||
2567 | file_id: FileId( | ||
2568 | 1, | ||
2569 | ), | ||
2570 | full_range: 13..28, | ||
2571 | focus_range: Some( | ||
2572 | 19..22, | ||
2573 | ), | ||
2574 | name: "Bar", | ||
2575 | kind: TRAIT, | ||
2576 | container_name: None, | ||
2577 | description: Some( | ||
2578 | "trait Bar", | ||
2579 | ), | ||
2580 | docs: None, | ||
2581 | }, | ||
2582 | }, | ||
2583 | HoverGotoTypeData { | ||
2584 | mod_path: "test::S", | ||
2585 | nav: NavigationTarget { | ||
2586 | file_id: FileId( | ||
2587 | 1, | ||
2588 | ), | ||
2589 | full_range: 29..39, | ||
2590 | focus_range: Some( | ||
2591 | 36..37, | ||
2592 | ), | ||
2593 | name: "S", | ||
2594 | kind: STRUCT, | ||
2595 | container_name: None, | ||
2596 | description: Some( | ||
2597 | "struct S", | ||
2598 | ), | ||
2599 | docs: None, | ||
2600 | }, | ||
2601 | }, | ||
2602 | ], | ||
2603 | ), | ||
2604 | ] | ||
2605 | "#]], | ||
2606 | ); | ||
2607 | } | ||
2608 | |||
2609 | #[test] | ||
2610 | fn test_hover_arg_generic_impl_trait_has_goto_type_action() { | ||
2611 | check_actions( | ||
2612 | r#" | ||
2613 | trait Foo<T> {} | ||
2614 | struct S {} | ||
2615 | fn foo(ar<|>g: &impl Foo<S>) {} | ||
2616 | "#, | ||
2617 | expect![[r#" | ||
2618 | [ | ||
2619 | GoToType( | ||
2620 | [ | ||
2621 | HoverGotoTypeData { | ||
2622 | mod_path: "test::Foo", | ||
2623 | nav: NavigationTarget { | ||
2624 | file_id: FileId( | ||
2625 | 1, | ||
2626 | ), | ||
2627 | full_range: 0..15, | ||
2628 | focus_range: Some( | ||
2629 | 6..9, | ||
2630 | ), | ||
2631 | name: "Foo", | ||
2632 | kind: TRAIT, | ||
2633 | container_name: None, | ||
2634 | description: Some( | ||
2635 | "trait Foo", | ||
2636 | ), | ||
2637 | docs: None, | ||
2638 | }, | ||
2639 | }, | ||
2640 | HoverGotoTypeData { | ||
2641 | mod_path: "test::S", | ||
2642 | nav: NavigationTarget { | ||
2643 | file_id: FileId( | ||
2644 | 1, | ||
2645 | ), | ||
2646 | full_range: 16..27, | ||
2647 | focus_range: Some( | ||
2648 | 23..24, | ||
2649 | ), | ||
2650 | name: "S", | ||
2651 | kind: STRUCT, | ||
2652 | container_name: None, | ||
2653 | description: Some( | ||
2654 | "struct S", | ||
2655 | ), | ||
2656 | docs: None, | ||
2657 | }, | ||
2658 | }, | ||
2659 | ], | ||
2660 | ), | ||
2661 | ] | ||
2662 | "#]], | ||
2663 | ); | ||
2664 | } | ||
2665 | |||
2666 | #[test] | ||
2667 | fn test_hover_dyn_return_has_goto_type_action() { | ||
2668 | check_actions( | ||
2669 | r#" | ||
2670 | trait Foo {} | ||
2671 | struct S; | ||
2672 | impl Foo for S {} | ||
2673 | |||
2674 | struct B<T>{} | ||
2675 | fn foo() -> B<dyn Foo> {} | ||
2676 | |||
2677 | fn main() { let s<|>t = foo(); } | ||
2678 | "#, | ||
2679 | expect![[r#" | ||
2680 | [ | ||
2681 | GoToType( | ||
2682 | [ | ||
2683 | HoverGotoTypeData { | ||
2684 | mod_path: "test::B", | ||
2685 | nav: NavigationTarget { | ||
2686 | file_id: FileId( | ||
2687 | 1, | ||
2688 | ), | ||
2689 | full_range: 42..55, | ||
2690 | focus_range: Some( | ||
2691 | 49..50, | ||
2692 | ), | ||
2693 | name: "B", | ||
2694 | kind: STRUCT, | ||
2695 | container_name: None, | ||
2696 | description: Some( | ||
2697 | "struct B", | ||
2698 | ), | ||
2699 | docs: None, | ||
2700 | }, | ||
2701 | }, | ||
2702 | HoverGotoTypeData { | ||
2703 | mod_path: "test::Foo", | ||
2704 | nav: NavigationTarget { | ||
2705 | file_id: FileId( | ||
2706 | 1, | ||
2707 | ), | ||
2708 | full_range: 0..12, | ||
2709 | focus_range: Some( | ||
2710 | 6..9, | ||
2711 | ), | ||
2712 | name: "Foo", | ||
2713 | kind: TRAIT, | ||
2714 | container_name: None, | ||
2715 | description: Some( | ||
2716 | "trait Foo", | ||
2717 | ), | ||
2718 | docs: None, | ||
2719 | }, | ||
2720 | }, | ||
2721 | ], | ||
2722 | ), | ||
2723 | ] | ||
2724 | "#]], | ||
2725 | ); | ||
2726 | } | ||
2727 | |||
2728 | #[test] | ||
2729 | fn test_hover_dyn_arg_has_goto_type_action() { | ||
2730 | check_actions( | ||
2731 | r#" | ||
2732 | trait Foo {} | ||
2733 | fn foo(ar<|>g: &dyn Foo) {} | ||
2734 | "#, | ||
2735 | expect![[r#" | ||
2736 | [ | ||
2737 | GoToType( | ||
2738 | [ | ||
2739 | HoverGotoTypeData { | ||
2740 | mod_path: "test::Foo", | ||
2741 | nav: NavigationTarget { | ||
2742 | file_id: FileId( | ||
2743 | 1, | ||
2744 | ), | ||
2745 | full_range: 0..12, | ||
2746 | focus_range: Some( | ||
2747 | 6..9, | ||
2748 | ), | ||
2749 | name: "Foo", | ||
2750 | kind: TRAIT, | ||
2751 | container_name: None, | ||
2752 | description: Some( | ||
2753 | "trait Foo", | ||
2754 | ), | ||
2755 | docs: None, | ||
2756 | }, | ||
2757 | }, | ||
2758 | ], | ||
2759 | ), | ||
2760 | ] | ||
2761 | "#]], | ||
2762 | ); | ||
2763 | } | ||
2764 | |||
2765 | #[test] | ||
2766 | fn test_hover_generic_dyn_arg_has_goto_type_action() { | ||
2767 | check_actions( | ||
2768 | r#" | ||
2769 | trait Foo<T> {} | ||
2770 | struct S {} | ||
2771 | fn foo(ar<|>g: &dyn Foo<S>) {} | ||
2772 | "#, | ||
2773 | expect![[r#" | ||
2774 | [ | ||
2775 | GoToType( | ||
2776 | [ | ||
2777 | HoverGotoTypeData { | ||
2778 | mod_path: "test::Foo", | ||
2779 | nav: NavigationTarget { | ||
2780 | file_id: FileId( | ||
2781 | 1, | ||
2782 | ), | ||
2783 | full_range: 0..15, | ||
2784 | focus_range: Some( | ||
2785 | 6..9, | ||
2786 | ), | ||
2787 | name: "Foo", | ||
2788 | kind: TRAIT, | ||
2789 | container_name: None, | ||
2790 | description: Some( | ||
2791 | "trait Foo", | ||
2792 | ), | ||
2793 | docs: None, | ||
2794 | }, | ||
2795 | }, | ||
2796 | HoverGotoTypeData { | ||
2797 | mod_path: "test::S", | ||
2798 | nav: NavigationTarget { | ||
2799 | file_id: FileId( | ||
2800 | 1, | ||
2801 | ), | ||
2802 | full_range: 16..27, | ||
2803 | focus_range: Some( | ||
2804 | 23..24, | ||
2805 | ), | ||
2806 | name: "S", | ||
2807 | kind: STRUCT, | ||
2808 | container_name: None, | ||
2809 | description: Some( | ||
2810 | "struct S", | ||
2811 | ), | ||
2812 | docs: None, | ||
2813 | }, | ||
2814 | }, | ||
2815 | ], | ||
2816 | ), | ||
2817 | ] | ||
2818 | "#]], | ||
2819 | ); | ||
2820 | } | ||
2821 | |||
2822 | #[test] | ||
2823 | fn test_hover_goto_type_action_links_order() { | ||
2824 | check_actions( | ||
2825 | r#" | ||
2826 | trait ImplTrait<T> {} | ||
2827 | trait DynTrait<T> {} | ||
2828 | struct B<T> {} | ||
2829 | struct S {} | ||
2830 | |||
2831 | fn foo(a<|>rg: &impl ImplTrait<B<dyn DynTrait<B<S>>>>) {} | ||
2832 | "#, | ||
2833 | expect![[r#" | ||
2834 | [ | ||
2835 | GoToType( | ||
2836 | [ | ||
2837 | HoverGotoTypeData { | ||
2838 | mod_path: "test::ImplTrait", | ||
2839 | nav: NavigationTarget { | ||
2840 | file_id: FileId( | ||
2841 | 1, | ||
2842 | ), | ||
2843 | full_range: 0..21, | ||
2844 | focus_range: Some( | ||
2845 | 6..15, | ||
2846 | ), | ||
2847 | name: "ImplTrait", | ||
2848 | kind: TRAIT, | ||
2849 | container_name: None, | ||
2850 | description: Some( | ||
2851 | "trait ImplTrait", | ||
2852 | ), | ||
2853 | docs: None, | ||
2854 | }, | ||
2855 | }, | ||
2856 | HoverGotoTypeData { | ||
2857 | mod_path: "test::B", | ||
2858 | nav: NavigationTarget { | ||
2859 | file_id: FileId( | ||
2860 | 1, | ||
2861 | ), | ||
2862 | full_range: 43..57, | ||
2863 | focus_range: Some( | ||
2864 | 50..51, | ||
2865 | ), | ||
2866 | name: "B", | ||
2867 | kind: STRUCT, | ||
2868 | container_name: None, | ||
2869 | description: Some( | ||
2870 | "struct B", | ||
2871 | ), | ||
2872 | docs: None, | ||
2873 | }, | ||
2874 | }, | ||
2875 | HoverGotoTypeData { | ||
2876 | mod_path: "test::DynTrait", | ||
2877 | nav: NavigationTarget { | ||
2878 | file_id: FileId( | ||
2879 | 1, | ||
2880 | ), | ||
2881 | full_range: 22..42, | ||
2882 | focus_range: Some( | ||
2883 | 28..36, | ||
2884 | ), | ||
2885 | name: "DynTrait", | ||
2886 | kind: TRAIT, | ||
2887 | container_name: None, | ||
2888 | description: Some( | ||
2889 | "trait DynTrait", | ||
2890 | ), | ||
2891 | docs: None, | ||
2892 | }, | ||
2893 | }, | ||
2894 | HoverGotoTypeData { | ||
2895 | mod_path: "test::S", | ||
2896 | nav: NavigationTarget { | ||
2897 | file_id: FileId( | ||
2898 | 1, | ||
2899 | ), | ||
2900 | full_range: 58..69, | ||
2901 | focus_range: Some( | ||
2902 | 65..66, | ||
2903 | ), | ||
2904 | name: "S", | ||
2905 | kind: STRUCT, | ||
2906 | container_name: None, | ||
2907 | description: Some( | ||
2908 | "struct S", | ||
2909 | ), | ||
2910 | docs: None, | ||
2911 | }, | ||
2912 | }, | ||
2913 | ], | ||
2914 | ), | ||
2915 | ] | ||
2916 | "#]], | ||
2917 | ); | ||
2918 | } | ||
2919 | |||
2920 | #[test] | ||
2921 | fn test_hover_associated_type_has_goto_type_action() { | ||
2922 | check_actions( | ||
2923 | r#" | ||
2924 | trait Foo { | ||
2925 | type Item; | ||
2926 | fn get(self) -> Self::Item {} | ||
2927 | } | ||
2928 | |||
2929 | struct Bar{} | ||
2930 | struct S{} | ||
2931 | |||
2932 | impl Foo for S { type Item = Bar; } | ||
2933 | |||
2934 | fn test() -> impl Foo { S {} } | ||
2935 | |||
2936 | fn main() { let s<|>t = test().get(); } | ||
2937 | "#, | ||
2938 | expect![[r#" | ||
2939 | [ | ||
2940 | GoToType( | ||
2941 | [ | ||
2942 | HoverGotoTypeData { | ||
2943 | mod_path: "test::Foo", | ||
2944 | nav: NavigationTarget { | ||
2945 | file_id: FileId( | ||
2946 | 1, | ||
2947 | ), | ||
2948 | full_range: 0..62, | ||
2949 | focus_range: Some( | ||
2950 | 6..9, | ||
2951 | ), | ||
2952 | name: "Foo", | ||
2953 | kind: TRAIT, | ||
2954 | container_name: None, | ||
2955 | description: Some( | ||
2956 | "trait Foo", | ||
2957 | ), | ||
2958 | docs: None, | ||
2959 | }, | ||
2960 | }, | ||
2961 | ], | ||
2962 | ), | ||
2963 | ] | ||
2964 | "#]], | ||
2965 | ); | ||
2966 | } | ||
2967 | } | ||