diff options
author | bors[bot] <26634292+bors[bot]@users.noreply.github.com> | 2020-10-06 12:43:08 +0100 |
---|---|---|
committer | GitHub <[email protected]> | 2020-10-06 12:43:08 +0100 |
commit | af0e54a566ab8c8be9b39a628aaa4992f161695c (patch) | |
tree | 6b12b51c50d64cd5412271101692d9e39282988f /crates/hir_def/src/find_path.rs | |
parent | 69512dae26278f06b5ac96a7b6093abb69cdd040 (diff) | |
parent | 86993310143c1347db6308a66c1f31a7a5644f56 (diff) |
Merge #6139
6139: Make find_path_prefixed configurable r=matklad a=Veykril
This makes `find_path_prefixed` more configurable allowing one to choose whether it always returns absolute paths, self-prefixed paths or to ignore local imports when building the path.
The config names are just thrown in here, taking better names if they exist :)
This should fix #6131 as well?
Co-authored-by: Lukas Wirth <[email protected]>
Diffstat (limited to 'crates/hir_def/src/find_path.rs')
-rw-r--r-- | crates/hir_def/src/find_path.rs | 247 |
1 files changed, 138 insertions, 109 deletions
diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs index baf374144..9106ed45f 100644 --- a/crates/hir_def/src/find_path.rs +++ b/crates/hir_def/src/find_path.rs | |||
@@ -19,12 +19,17 @@ use crate::{ | |||
19 | /// *from where* you're referring to the item, hence the `from` parameter. | 19 | /// *from where* you're referring to the item, hence the `from` parameter. |
20 | pub fn find_path(db: &dyn DefDatabase, item: ItemInNs, from: ModuleId) -> Option<ModPath> { | 20 | pub fn find_path(db: &dyn DefDatabase, item: ItemInNs, from: ModuleId) -> Option<ModPath> { |
21 | let _p = profile::span("find_path"); | 21 | let _p = profile::span("find_path"); |
22 | find_path_inner(db, item, from, MAX_PATH_LEN, Prefixed::Not) | 22 | find_path_inner(db, item, from, MAX_PATH_LEN, None) |
23 | } | 23 | } |
24 | 24 | ||
25 | pub fn find_path_prefixed(db: &dyn DefDatabase, item: ItemInNs, from: ModuleId) -> Option<ModPath> { | 25 | pub fn find_path_prefixed( |
26 | let _p = profile::span("find_path_absolute"); | 26 | db: &dyn DefDatabase, |
27 | find_path_inner(db, item, from, MAX_PATH_LEN, Prefixed::Plain) | 27 | item: ItemInNs, |
28 | from: ModuleId, | ||
29 | prefix_kind: PrefixKind, | ||
30 | ) -> Option<ModPath> { | ||
31 | let _p = profile::span("find_path_prefixed"); | ||
32 | find_path_inner(db, item, from, MAX_PATH_LEN, Some(prefix_kind)) | ||
28 | } | 33 | } |
29 | 34 | ||
30 | const MAX_PATH_LEN: usize = 15; | 35 | const MAX_PATH_LEN: usize = 15; |
@@ -42,58 +47,52 @@ impl ModPath { | |||
42 | } | 47 | } |
43 | } | 48 | } |
44 | 49 | ||
45 | fn check_crate_self_super( | 50 | fn check_self_super(def_map: &CrateDefMap, item: ItemInNs, from: ModuleId) -> Option<ModPath> { |
46 | def_map: &CrateDefMap, | 51 | if item == ItemInNs::Types(from.into()) { |
47 | item: ItemInNs, | ||
48 | from: ModuleId, | ||
49 | ) -> Option<ModPath> { | ||
50 | // - if the item is the crate root, return `crate` | ||
51 | if item | ||
52 | == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId { | ||
53 | krate: from.krate, | ||
54 | local_id: def_map.root, | ||
55 | })) | ||
56 | { | ||
57 | Some(ModPath::from_segments(PathKind::Crate, Vec::new())) | ||
58 | } else if item == ItemInNs::Types(from.into()) { | ||
59 | // - if the item is the module we're in, use `self` | 52 | // - if the item is the module we're in, use `self` |
60 | Some(ModPath::from_segments(PathKind::Super(0), Vec::new())) | 53 | Some(ModPath::from_segments(PathKind::Super(0), Vec::new())) |
61 | } else { | 54 | } else if let Some(parent_id) = def_map.modules[from.local_id].parent { |
62 | if let Some(parent_id) = def_map.modules[from.local_id].parent { | 55 | // - if the item is the parent module, use `super` (this is not used recursively, since `super::super` is ugly) |
63 | // - if the item is the parent module, use `super` (this is not used recursively, since `super::super` is ugly) | 56 | if item |
64 | if item | 57 | == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId { |
65 | == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId { | 58 | krate: from.krate, |
66 | krate: from.krate, | 59 | local_id: parent_id, |
67 | local_id: parent_id, | 60 | })) |
68 | })) | 61 | { |
69 | { | 62 | Some(ModPath::from_segments(PathKind::Super(1), Vec::new())) |
70 | return Some(ModPath::from_segments(PathKind::Super(1), Vec::new())); | 63 | } else { |
71 | } | 64 | None |
72 | } | 65 | } |
66 | } else { | ||
73 | None | 67 | None |
74 | } | 68 | } |
75 | } | 69 | } |
76 | 70 | ||
77 | #[derive(Copy, Clone, PartialEq, Eq)] | 71 | #[derive(Copy, Clone, Debug, PartialEq, Eq)] |
78 | pub enum Prefixed { | 72 | pub enum PrefixKind { |
79 | Not, | 73 | /// Causes paths to always start with either `self`, `super`, `crate` or a crate-name. |
74 | /// This is the same as plain, just that paths will start with `self` iprepended f the path | ||
75 | /// starts with an identifier that is not a crate. | ||
80 | BySelf, | 76 | BySelf, |
77 | /// Causes paths to ignore imports in the local module. | ||
81 | Plain, | 78 | Plain, |
79 | /// Causes paths to start with `crate` where applicable, effectively forcing paths to be absolute. | ||
80 | ByCrate, | ||
82 | } | 81 | } |
83 | 82 | ||
84 | impl Prefixed { | 83 | impl PrefixKind { |
85 | #[inline] | 84 | #[inline] |
86 | fn prefix(self) -> Option<PathKind> { | 85 | fn prefix(self) -> PathKind { |
87 | match self { | 86 | match self { |
88 | Prefixed::Not => None, | 87 | PrefixKind::BySelf => PathKind::Super(0), |
89 | Prefixed::BySelf => Some(PathKind::Super(0)), | 88 | PrefixKind::Plain => PathKind::Plain, |
90 | Prefixed::Plain => Some(PathKind::Plain), | 89 | PrefixKind::ByCrate => PathKind::Crate, |
91 | } | 90 | } |
92 | } | 91 | } |
93 | 92 | ||
94 | #[inline] | 93 | #[inline] |
95 | fn prefixed(self) -> bool { | 94 | fn is_absolute(&self) -> bool { |
96 | self != Prefixed::Not | 95 | self == &PrefixKind::ByCrate |
97 | } | 96 | } |
98 | } | 97 | } |
99 | 98 | ||
@@ -102,7 +101,7 @@ fn find_path_inner( | |||
102 | item: ItemInNs, | 101 | item: ItemInNs, |
103 | from: ModuleId, | 102 | from: ModuleId, |
104 | max_len: usize, | 103 | max_len: usize, |
105 | prefixed: Prefixed, | 104 | prefixed: Option<PrefixKind>, |
106 | ) -> Option<ModPath> { | 105 | ) -> Option<ModPath> { |
107 | if max_len == 0 { | 106 | if max_len == 0 { |
108 | return None; | 107 | return None; |
@@ -115,13 +114,25 @@ fn find_path_inner( | |||
115 | let from_scope: &crate::item_scope::ItemScope = &def_map.modules[from.local_id].scope; | 114 | let from_scope: &crate::item_scope::ItemScope = &def_map.modules[from.local_id].scope; |
116 | let scope_name = | 115 | let scope_name = |
117 | if let Some((name, _)) = from_scope.name_of(item) { Some(name.clone()) } else { None }; | 116 | if let Some((name, _)) = from_scope.name_of(item) { Some(name.clone()) } else { None }; |
118 | if !prefixed.prefixed() && scope_name.is_some() { | 117 | if prefixed.is_none() && scope_name.is_some() { |
119 | return scope_name | 118 | return scope_name |
120 | .map(|scope_name| ModPath::from_segments(PathKind::Plain, vec![scope_name])); | 119 | .map(|scope_name| ModPath::from_segments(PathKind::Plain, vec![scope_name])); |
121 | } | 120 | } |
122 | 121 | ||
123 | if let modpath @ Some(_) = check_crate_self_super(&def_map, item, from) { | 122 | // - if the item is the crate root, return `crate` |
124 | return modpath; | 123 | if item |
124 | == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId { | ||
125 | krate: from.krate, | ||
126 | local_id: def_map.root, | ||
127 | })) | ||
128 | { | ||
129 | return Some(ModPath::from_segments(PathKind::Crate, Vec::new())); | ||
130 | } | ||
131 | |||
132 | if prefixed.filter(PrefixKind::is_absolute).is_none() { | ||
133 | if let modpath @ Some(_) = check_self_super(&def_map, item, from) { | ||
134 | return modpath; | ||
135 | } | ||
125 | } | 136 | } |
126 | 137 | ||
127 | // - if the item is the crate root of a dependency crate, return the name from the extern prelude | 138 | // - if the item is the crate root of a dependency crate, return the name from the extern prelude |
@@ -226,7 +237,7 @@ fn find_path_inner( | |||
226 | } | 237 | } |
227 | } | 238 | } |
228 | 239 | ||
229 | if let Some(prefix) = prefixed.prefix() { | 240 | if let Some(prefix) = prefixed.map(PrefixKind::prefix) { |
230 | best_path.or_else(|| { | 241 | best_path.or_else(|| { |
231 | scope_name.map(|scope_name| ModPath::from_segments(prefix, vec![scope_name])) | 242 | scope_name.map(|scope_name| ModPath::from_segments(prefix, vec![scope_name])) |
232 | }) | 243 | }) |
@@ -355,7 +366,7 @@ mod tests { | |||
355 | /// `code` needs to contain a cursor marker; checks that `find_path` for the | 366 | /// `code` needs to contain a cursor marker; checks that `find_path` for the |
356 | /// item the `path` refers to returns that same path when called from the | 367 | /// item the `path` refers to returns that same path when called from the |
357 | /// module the cursor is in. | 368 | /// module the cursor is in. |
358 | fn check_found_path_(ra_fixture: &str, path: &str, absolute: bool) { | 369 | fn check_found_path_(ra_fixture: &str, path: &str, prefix_kind: Option<PrefixKind>) { |
359 | let (db, pos) = TestDB::with_position(ra_fixture); | 370 | let (db, pos) = TestDB::with_position(ra_fixture); |
360 | let module = db.module_for_file(pos.file_id); | 371 | let module = db.module_for_file(pos.file_id); |
361 | let parsed_path_file = syntax::SourceFile::parse(&format!("use {};", path)); | 372 | let parsed_path_file = syntax::SourceFile::parse(&format!("use {};", path)); |
@@ -375,20 +386,22 @@ mod tests { | |||
375 | .take_types() | 386 | .take_types() |
376 | .unwrap(); | 387 | .unwrap(); |
377 | 388 | ||
378 | let found_path = if absolute { find_path_prefixed } else { find_path }( | 389 | let found_path = |
379 | &db, | 390 | find_path_inner(&db, ItemInNs::Types(resolved), module, MAX_PATH_LEN, prefix_kind); |
380 | ItemInNs::Types(resolved), | 391 | assert_eq!(found_path, Some(mod_path), "{:?}", prefix_kind); |
381 | module, | ||
382 | ); | ||
383 | assert_eq!(found_path, Some(mod_path), "absolute {}", absolute); | ||
384 | } | 392 | } |
385 | 393 | ||
386 | fn check_found_path(ra_fixture: &str, path: &str) { | 394 | fn check_found_path( |
387 | check_found_path_(ra_fixture, path, false); | 395 | ra_fixture: &str, |
388 | } | 396 | unprefixed: &str, |
389 | 397 | prefixed: &str, | |
390 | fn check_found_path_abs(ra_fixture: &str, path: &str) { | 398 | absolute: &str, |
391 | check_found_path_(ra_fixture, path, true); | 399 | self_prefixed: &str, |
400 | ) { | ||
401 | check_found_path_(ra_fixture, unprefixed, None); | ||
402 | check_found_path_(ra_fixture, prefixed, Some(PrefixKind::Plain)); | ||
403 | check_found_path_(ra_fixture, absolute, Some(PrefixKind::ByCrate)); | ||
404 | check_found_path_(ra_fixture, self_prefixed, Some(PrefixKind::BySelf)); | ||
392 | } | 405 | } |
393 | 406 | ||
394 | #[test] | 407 | #[test] |
@@ -398,8 +411,7 @@ mod tests { | |||
398 | struct S; | 411 | struct S; |
399 | <|> | 412 | <|> |
400 | "#; | 413 | "#; |
401 | check_found_path(code, "S"); | 414 | check_found_path(code, "S", "S", "crate::S", "self::S"); |
402 | check_found_path_abs(code, "S"); | ||
403 | } | 415 | } |
404 | 416 | ||
405 | #[test] | 417 | #[test] |
@@ -409,8 +421,7 @@ mod tests { | |||
409 | enum E { A } | 421 | enum E { A } |
410 | <|> | 422 | <|> |
411 | "#; | 423 | "#; |
412 | check_found_path(code, "E::A"); | 424 | check_found_path(code, "E::A", "E::A", "E::A", "E::A"); |
413 | check_found_path_abs(code, "E::A"); | ||
414 | } | 425 | } |
415 | 426 | ||
416 | #[test] | 427 | #[test] |
@@ -422,8 +433,7 @@ mod tests { | |||
422 | } | 433 | } |
423 | <|> | 434 | <|> |
424 | "#; | 435 | "#; |
425 | check_found_path(code, "foo::S"); | 436 | check_found_path(code, "foo::S", "foo::S", "crate::foo::S", "self::foo::S"); |
426 | check_found_path_abs(code, "foo::S"); | ||
427 | } | 437 | } |
428 | 438 | ||
429 | #[test] | 439 | #[test] |
@@ -437,8 +447,7 @@ mod tests { | |||
437 | //- /foo/bar.rs | 447 | //- /foo/bar.rs |
438 | <|> | 448 | <|> |
439 | "#; | 449 | "#; |
440 | check_found_path(code, "super::S"); | 450 | check_found_path(code, "super::S", "super::S", "crate::foo::S", "super::S"); |
441 | check_found_path_abs(code, "super::S"); | ||
442 | } | 451 | } |
443 | 452 | ||
444 | #[test] | 453 | #[test] |
@@ -449,8 +458,7 @@ mod tests { | |||
449 | //- /foo.rs | 458 | //- /foo.rs |
450 | <|> | 459 | <|> |
451 | "#; | 460 | "#; |
452 | check_found_path(code, "self"); | 461 | check_found_path(code, "self", "self", "crate::foo", "self"); |
453 | check_found_path_abs(code, "self"); | ||
454 | } | 462 | } |
455 | 463 | ||
456 | #[test] | 464 | #[test] |
@@ -461,8 +469,7 @@ mod tests { | |||
461 | //- /foo.rs | 469 | //- /foo.rs |
462 | <|> | 470 | <|> |
463 | "#; | 471 | "#; |
464 | check_found_path(code, "crate"); | 472 | check_found_path(code, "crate", "crate", "crate", "crate"); |
465 | check_found_path_abs(code, "crate"); | ||
466 | } | 473 | } |
467 | 474 | ||
468 | #[test] | 475 | #[test] |
@@ -474,8 +481,7 @@ mod tests { | |||
474 | //- /foo.rs | 481 | //- /foo.rs |
475 | <|> | 482 | <|> |
476 | "#; | 483 | "#; |
477 | check_found_path(code, "crate::S"); | 484 | check_found_path(code, "crate::S", "crate::S", "crate::S", "crate::S"); |
478 | check_found_path_abs(code, "crate::S"); | ||
479 | } | 485 | } |
480 | 486 | ||
481 | #[test] | 487 | #[test] |
@@ -486,8 +492,7 @@ mod tests { | |||
486 | //- /std.rs crate:std | 492 | //- /std.rs crate:std |
487 | pub struct S; | 493 | pub struct S; |
488 | "#; | 494 | "#; |
489 | check_found_path(code, "std::S"); | 495 | check_found_path(code, "std::S", "std::S", "std::S", "std::S"); |
490 | check_found_path_abs(code, "std::S"); | ||
491 | } | 496 | } |
492 | 497 | ||
493 | #[test] | 498 | #[test] |
@@ -499,8 +504,13 @@ mod tests { | |||
499 | //- /std.rs crate:std | 504 | //- /std.rs crate:std |
500 | pub struct S; | 505 | pub struct S; |
501 | "#; | 506 | "#; |
502 | check_found_path(code, "std_renamed::S"); | 507 | check_found_path( |
503 | check_found_path_abs(code, "std_renamed::S"); | 508 | code, |
509 | "std_renamed::S", | ||
510 | "std_renamed::S", | ||
511 | "std_renamed::S", | ||
512 | "std_renamed::S", | ||
513 | ); | ||
504 | } | 514 | } |
505 | 515 | ||
506 | #[test] | 516 | #[test] |
@@ -520,8 +530,13 @@ mod tests { | |||
520 | } | 530 | } |
521 | } | 531 | } |
522 | "#; | 532 | "#; |
523 | check_found_path(code, "ast::ModuleItem"); | 533 | check_found_path( |
524 | check_found_path_abs(code, "syntax::ast::ModuleItem"); | 534 | code, |
535 | "ast::ModuleItem", | ||
536 | "syntax::ast::ModuleItem", | ||
537 | "syntax::ast::ModuleItem", | ||
538 | "syntax::ast::ModuleItem", | ||
539 | ); | ||
525 | 540 | ||
526 | let code = r#" | 541 | let code = r#" |
527 | //- /main.rs crate:main deps:syntax | 542 | //- /main.rs crate:main deps:syntax |
@@ -535,8 +550,13 @@ mod tests { | |||
535 | } | 550 | } |
536 | } | 551 | } |
537 | "#; | 552 | "#; |
538 | check_found_path(code, "syntax::ast::ModuleItem"); | 553 | check_found_path( |
539 | check_found_path_abs(code, "syntax::ast::ModuleItem"); | 554 | code, |
555 | "syntax::ast::ModuleItem", | ||
556 | "syntax::ast::ModuleItem", | ||
557 | "syntax::ast::ModuleItem", | ||
558 | "syntax::ast::ModuleItem", | ||
559 | ); | ||
540 | } | 560 | } |
541 | 561 | ||
542 | #[test] | 562 | #[test] |
@@ -549,8 +569,7 @@ mod tests { | |||
549 | } | 569 | } |
550 | <|> | 570 | <|> |
551 | "#; | 571 | "#; |
552 | check_found_path(code, "bar::S"); | 572 | check_found_path(code, "bar::S", "bar::S", "crate::bar::S", "self::bar::S"); |
553 | check_found_path_abs(code, "bar::S"); | ||
554 | } | 573 | } |
555 | 574 | ||
556 | #[test] | 575 | #[test] |
@@ -563,8 +582,7 @@ mod tests { | |||
563 | } | 582 | } |
564 | <|> | 583 | <|> |
565 | "#; | 584 | "#; |
566 | check_found_path(code, "bar::U"); | 585 | check_found_path(code, "bar::U", "bar::U", "crate::bar::U", "self::bar::U"); |
567 | check_found_path_abs(code, "bar::U"); | ||
568 | } | 586 | } |
569 | 587 | ||
570 | #[test] | 588 | #[test] |
@@ -577,8 +595,7 @@ mod tests { | |||
577 | //- /core.rs crate:core | 595 | //- /core.rs crate:core |
578 | pub struct S; | 596 | pub struct S; |
579 | "#; | 597 | "#; |
580 | check_found_path(code, "std::S"); | 598 | check_found_path(code, "std::S", "std::S", "std::S", "std::S"); |
581 | check_found_path_abs(code, "std::S"); | ||
582 | } | 599 | } |
583 | 600 | ||
584 | #[test] | 601 | #[test] |
@@ -591,8 +608,7 @@ mod tests { | |||
591 | #[prelude_import] | 608 | #[prelude_import] |
592 | pub use prelude::*; | 609 | pub use prelude::*; |
593 | "#; | 610 | "#; |
594 | check_found_path(code, "S"); | 611 | check_found_path(code, "S", "S", "S", "S"); |
595 | check_found_path_abs(code, "S"); | ||
596 | } | 612 | } |
597 | 613 | ||
598 | #[test] | 614 | #[test] |
@@ -608,10 +624,8 @@ mod tests { | |||
608 | #[prelude_import] | 624 | #[prelude_import] |
609 | pub use prelude::*; | 625 | pub use prelude::*; |
610 | "#; | 626 | "#; |
611 | check_found_path(code, "None"); | 627 | check_found_path(code, "None", "None", "None", "None"); |
612 | check_found_path(code, "Some"); | 628 | check_found_path(code, "Some", "Some", "Some", "Some"); |
613 | check_found_path_abs(code, "None"); | ||
614 | check_found_path_abs(code, "Some"); | ||
615 | } | 629 | } |
616 | 630 | ||
617 | #[test] | 631 | #[test] |
@@ -627,8 +641,7 @@ mod tests { | |||
627 | //- /baz.rs | 641 | //- /baz.rs |
628 | pub use crate::foo::bar::S; | 642 | pub use crate::foo::bar::S; |
629 | "#; | 643 | "#; |
630 | check_found_path(code, "baz::S"); | 644 | check_found_path(code, "baz::S", "baz::S", "crate::baz::S", "self::baz::S"); |
631 | check_found_path_abs(code, "baz::S"); | ||
632 | } | 645 | } |
633 | 646 | ||
634 | #[test] | 647 | #[test] |
@@ -642,8 +655,7 @@ mod tests { | |||
642 | <|> | 655 | <|> |
643 | "#; | 656 | "#; |
644 | // crate::S would be shorter, but using private imports seems wrong | 657 | // crate::S would be shorter, but using private imports seems wrong |
645 | check_found_path(code, "crate::bar::S"); | 658 | check_found_path(code, "crate::bar::S", "crate::bar::S", "crate::bar::S", "crate::bar::S"); |
646 | check_found_path_abs(code, "crate::bar::S"); | ||
647 | } | 659 | } |
648 | 660 | ||
649 | #[test] | 661 | #[test] |
@@ -661,8 +673,7 @@ mod tests { | |||
661 | //- /baz.rs | 673 | //- /baz.rs |
662 | pub use super::foo; | 674 | pub use super::foo; |
663 | "#; | 675 | "#; |
664 | check_found_path(code, "crate::foo::S"); | 676 | check_found_path(code, "crate::foo::S", "crate::foo::S", "crate::foo::S", "crate::foo::S"); |
665 | check_found_path_abs(code, "crate::foo::S"); | ||
666 | } | 677 | } |
667 | 678 | ||
668 | #[test] | 679 | #[test] |
@@ -682,8 +693,13 @@ mod tests { | |||
682 | pub struct Arc; | 693 | pub struct Arc; |
683 | } | 694 | } |
684 | "#; | 695 | "#; |
685 | check_found_path(code, "std::sync::Arc"); | 696 | check_found_path( |
686 | check_found_path_abs(code, "std::sync::Arc"); | 697 | code, |
698 | "std::sync::Arc", | ||
699 | "std::sync::Arc", | ||
700 | "std::sync::Arc", | ||
701 | "std::sync::Arc", | ||
702 | ); | ||
687 | } | 703 | } |
688 | 704 | ||
689 | #[test] | 705 | #[test] |
@@ -707,8 +723,13 @@ mod tests { | |||
707 | pub struct Error; | 723 | pub struct Error; |
708 | } | 724 | } |
709 | "#; | 725 | "#; |
710 | check_found_path(code, "core::fmt::Error"); | 726 | check_found_path( |
711 | check_found_path_abs(code, "core::fmt::Error"); | 727 | code, |
728 | "core::fmt::Error", | ||
729 | "core::fmt::Error", | ||
730 | "core::fmt::Error", | ||
731 | "core::fmt::Error", | ||
732 | ); | ||
712 | } | 733 | } |
713 | 734 | ||
714 | #[test] | 735 | #[test] |
@@ -731,8 +752,13 @@ mod tests { | |||
731 | pub struct Arc; | 752 | pub struct Arc; |
732 | } | 753 | } |
733 | "#; | 754 | "#; |
734 | check_found_path(code, "alloc::sync::Arc"); | 755 | check_found_path( |
735 | check_found_path_abs(code, "alloc::sync::Arc"); | 756 | code, |
757 | "alloc::sync::Arc", | ||
758 | "alloc::sync::Arc", | ||
759 | "alloc::sync::Arc", | ||
760 | "alloc::sync::Arc", | ||
761 | ); | ||
736 | } | 762 | } |
737 | 763 | ||
738 | #[test] | 764 | #[test] |
@@ -749,8 +775,13 @@ mod tests { | |||
749 | //- /zzz.rs crate:megaalloc | 775 | //- /zzz.rs crate:megaalloc |
750 | pub struct Arc; | 776 | pub struct Arc; |
751 | "#; | 777 | "#; |
752 | check_found_path(code, "megaalloc::Arc"); | 778 | check_found_path( |
753 | check_found_path_abs(code, "megaalloc::Arc"); | 779 | code, |
780 | "megaalloc::Arc", | ||
781 | "megaalloc::Arc", | ||
782 | "megaalloc::Arc", | ||
783 | "megaalloc::Arc", | ||
784 | ); | ||
754 | } | 785 | } |
755 | 786 | ||
756 | #[test] | 787 | #[test] |
@@ -763,9 +794,7 @@ mod tests { | |||
763 | pub use u8; | 794 | pub use u8; |
764 | } | 795 | } |
765 | "#; | 796 | "#; |
766 | check_found_path(code, "u8"); | 797 | check_found_path(code, "u8", "u8", "u8", "u8"); |
767 | check_found_path(code, "u16"); | 798 | check_found_path(code, "u16", "u16", "u16", "u16"); |
768 | check_found_path_abs(code, "u8"); | ||
769 | check_found_path_abs(code, "u16"); | ||
770 | } | 799 | } |
771 | } | 800 | } |