diff options
Diffstat (limited to 'crates/ra_hir_def/src/nameres/tests/mod_resolution.rs')
-rw-r--r-- | crates/ra_hir_def/src/nameres/tests/mod_resolution.rs | 782 |
1 files changed, 782 insertions, 0 deletions
diff --git a/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs b/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs new file mode 100644 index 000000000..dee364a14 --- /dev/null +++ b/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs | |||
@@ -0,0 +1,782 @@ | |||
1 | use super::*; | ||
2 | |||
3 | #[test] | ||
4 | fn name_res_works_for_broken_modules() { | ||
5 | covers!(name_res_works_for_broken_modules); | ||
6 | let map = def_map( | ||
7 | " | ||
8 | //- /lib.rs | ||
9 | mod foo // no `;`, no body | ||
10 | |||
11 | use self::foo::Baz; | ||
12 | |||
13 | //- /foo/mod.rs | ||
14 | pub mod bar; | ||
15 | |||
16 | pub use self::bar::Baz; | ||
17 | |||
18 | //- /foo/bar.rs | ||
19 | pub struct Baz; | ||
20 | ", | ||
21 | ); | ||
22 | assert_snapshot!(map, @r###" | ||
23 | ⋮crate | ||
24 | ⋮Baz: _ | ||
25 | "###); | ||
26 | } | ||
27 | |||
28 | #[test] | ||
29 | fn nested_module_resolution() { | ||
30 | let map = def_map( | ||
31 | " | ||
32 | //- /lib.rs | ||
33 | mod n1; | ||
34 | |||
35 | //- /n1.rs | ||
36 | mod n2; | ||
37 | |||
38 | //- /n1/n2.rs | ||
39 | struct X; | ||
40 | ", | ||
41 | ); | ||
42 | |||
43 | assert_snapshot!(map, @r###" | ||
44 | ⋮crate | ||
45 | ⋮n1: t | ||
46 | ⋮ | ||
47 | ⋮crate::n1 | ||
48 | ⋮n2: t | ||
49 | ⋮ | ||
50 | ⋮crate::n1::n2 | ||
51 | ⋮X: t v | ||
52 | "###); | ||
53 | } | ||
54 | |||
55 | #[test] | ||
56 | fn module_resolution_works_for_non_standard_filenames() { | ||
57 | let map = def_map( | ||
58 | " | ||
59 | //- /my_library.rs crate:my_library | ||
60 | mod foo; | ||
61 | use self::foo::Bar; | ||
62 | |||
63 | //- /foo/mod.rs | ||
64 | pub struct Bar; | ||
65 | ", | ||
66 | ); | ||
67 | |||
68 | assert_snapshot!(map, @r###" | ||
69 | ⋮crate | ||
70 | ⋮Bar: t v | ||
71 | ⋮foo: t | ||
72 | ⋮ | ||
73 | ⋮crate::foo | ||
74 | ⋮Bar: t v | ||
75 | "###); | ||
76 | } | ||
77 | |||
78 | #[test] | ||
79 | fn module_resolution_works_for_raw_modules() { | ||
80 | let map = def_map( | ||
81 | " | ||
82 | //- /lib.rs | ||
83 | mod r#async; | ||
84 | use self::r#async::Bar; | ||
85 | |||
86 | //- /async.rs | ||
87 | pub struct Bar; | ||
88 | ", | ||
89 | ); | ||
90 | |||
91 | assert_snapshot!(map, @r###" | ||
92 | ⋮crate | ||
93 | ⋮Bar: t v | ||
94 | ⋮async: t | ||
95 | ⋮ | ||
96 | ⋮crate::async | ||
97 | ⋮Bar: t v | ||
98 | "###); | ||
99 | } | ||
100 | |||
101 | #[test] | ||
102 | fn module_resolution_decl_path() { | ||
103 | let map = def_map( | ||
104 | r###" | ||
105 | //- /lib.rs | ||
106 | #[path = "bar/baz/foo.rs"] | ||
107 | mod foo; | ||
108 | use self::foo::Bar; | ||
109 | |||
110 | //- /bar/baz/foo.rs | ||
111 | pub struct Bar; | ||
112 | "###, | ||
113 | ); | ||
114 | |||
115 | assert_snapshot!(map, @r###" | ||
116 | ⋮crate | ||
117 | ⋮Bar: t v | ||
118 | ⋮foo: t | ||
119 | ⋮ | ||
120 | ⋮crate::foo | ||
121 | ⋮Bar: t v | ||
122 | "###); | ||
123 | } | ||
124 | |||
125 | #[test] | ||
126 | fn module_resolution_module_with_path_in_mod_rs() { | ||
127 | let map = def_map( | ||
128 | r###" | ||
129 | //- /main.rs | ||
130 | mod foo; | ||
131 | |||
132 | //- /foo/mod.rs | ||
133 | #[path = "baz.rs"] | ||
134 | pub mod bar; | ||
135 | |||
136 | use self::bar::Baz; | ||
137 | |||
138 | //- /foo/baz.rs | ||
139 | pub struct Baz; | ||
140 | "###, | ||
141 | ); | ||
142 | |||
143 | assert_snapshot!(map, @r###" | ||
144 | ⋮crate | ||
145 | ⋮foo: t | ||
146 | ⋮ | ||
147 | ⋮crate::foo | ||
148 | ⋮Baz: t v | ||
149 | ⋮bar: t | ||
150 | ⋮ | ||
151 | ⋮crate::foo::bar | ||
152 | ⋮Baz: t v | ||
153 | "###); | ||
154 | } | ||
155 | |||
156 | #[test] | ||
157 | fn module_resolution_module_with_path_non_crate_root() { | ||
158 | let map = def_map( | ||
159 | r###" | ||
160 | //- /main.rs | ||
161 | mod foo; | ||
162 | |||
163 | //- /foo.rs | ||
164 | #[path = "baz.rs"] | ||
165 | pub mod bar; | ||
166 | |||
167 | use self::bar::Baz; | ||
168 | |||
169 | //- /baz.rs | ||
170 | pub struct Baz; | ||
171 | "###, | ||
172 | ); | ||
173 | |||
174 | assert_snapshot!(map, @r###" | ||
175 | ⋮crate | ||
176 | ⋮foo: t | ||
177 | ⋮ | ||
178 | ⋮crate::foo | ||
179 | ⋮Baz: t v | ||
180 | ⋮bar: t | ||
181 | ⋮ | ||
182 | ⋮crate::foo::bar | ||
183 | ⋮Baz: t v | ||
184 | "###); | ||
185 | } | ||
186 | |||
187 | #[test] | ||
188 | fn module_resolution_module_decl_path_super() { | ||
189 | let map = def_map( | ||
190 | r###" | ||
191 | //- /main.rs | ||
192 | #[path = "bar/baz/module.rs"] | ||
193 | mod foo; | ||
194 | pub struct Baz; | ||
195 | |||
196 | //- /bar/baz/module.rs | ||
197 | use super::Baz; | ||
198 | "###, | ||
199 | ); | ||
200 | |||
201 | assert_snapshot!(map, @r###" | ||
202 | ⋮crate | ||
203 | ⋮Baz: t v | ||
204 | ⋮foo: t | ||
205 | ⋮ | ||
206 | ⋮crate::foo | ||
207 | ⋮Baz: t v | ||
208 | "###); | ||
209 | } | ||
210 | |||
211 | #[test] | ||
212 | fn module_resolution_explicit_path_mod_rs() { | ||
213 | let map = def_map( | ||
214 | r###" | ||
215 | //- /main.rs | ||
216 | #[path = "module/mod.rs"] | ||
217 | mod foo; | ||
218 | |||
219 | //- /module/mod.rs | ||
220 | pub struct Baz; | ||
221 | "###, | ||
222 | ); | ||
223 | |||
224 | assert_snapshot!(map, @r###" | ||
225 | ⋮crate | ||
226 | ⋮foo: t | ||
227 | ⋮ | ||
228 | ⋮crate::foo | ||
229 | ⋮Baz: t v | ||
230 | "###); | ||
231 | } | ||
232 | |||
233 | #[test] | ||
234 | fn module_resolution_relative_path() { | ||
235 | let map = def_map( | ||
236 | r###" | ||
237 | //- /main.rs | ||
238 | mod foo; | ||
239 | |||
240 | //- /foo.rs | ||
241 | #[path = "./sub.rs"] | ||
242 | pub mod foo_bar; | ||
243 | |||
244 | //- /sub.rs | ||
245 | pub struct Baz; | ||
246 | "###, | ||
247 | ); | ||
248 | |||
249 | assert_snapshot!(map, @r###" | ||
250 | ⋮crate | ||
251 | ⋮foo: t | ||
252 | ⋮ | ||
253 | ⋮crate::foo | ||
254 | ⋮foo_bar: t | ||
255 | ⋮ | ||
256 | ⋮crate::foo::foo_bar | ||
257 | ⋮Baz: t v | ||
258 | "###); | ||
259 | } | ||
260 | |||
261 | #[test] | ||
262 | fn module_resolution_relative_path_2() { | ||
263 | let map = def_map( | ||
264 | r###" | ||
265 | //- /main.rs | ||
266 | mod foo; | ||
267 | |||
268 | //- /foo/mod.rs | ||
269 | #[path="../sub.rs"] | ||
270 | pub mod foo_bar; | ||
271 | |||
272 | //- /sub.rs | ||
273 | pub struct Baz; | ||
274 | "###, | ||
275 | ); | ||
276 | |||
277 | assert_snapshot!(map, @r###" | ||
278 | ⋮crate | ||
279 | ⋮foo: t | ||
280 | ⋮ | ||
281 | ⋮crate::foo | ||
282 | ⋮foo_bar: t | ||
283 | ⋮ | ||
284 | ⋮crate::foo::foo_bar | ||
285 | ⋮Baz: t v | ||
286 | "###); | ||
287 | } | ||
288 | |||
289 | #[test] | ||
290 | fn module_resolution_explicit_path_mod_rs_2() { | ||
291 | let map = def_map( | ||
292 | r###" | ||
293 | //- /main.rs | ||
294 | #[path = "module/bar/mod.rs"] | ||
295 | mod foo; | ||
296 | |||
297 | //- /module/bar/mod.rs | ||
298 | pub struct Baz; | ||
299 | "###, | ||
300 | ); | ||
301 | |||
302 | assert_snapshot!(map, @r###" | ||
303 | ⋮crate | ||
304 | ⋮foo: t | ||
305 | ⋮ | ||
306 | ⋮crate::foo | ||
307 | ⋮Baz: t v | ||
308 | "###); | ||
309 | } | ||
310 | |||
311 | #[test] | ||
312 | fn module_resolution_explicit_path_mod_rs_with_win_separator() { | ||
313 | let map = def_map( | ||
314 | r###" | ||
315 | //- /main.rs | ||
316 | #[path = "module\bar\mod.rs"] | ||
317 | mod foo; | ||
318 | |||
319 | //- /module/bar/mod.rs | ||
320 | pub struct Baz; | ||
321 | "###, | ||
322 | ); | ||
323 | |||
324 | assert_snapshot!(map, @r###" | ||
325 | ⋮crate | ||
326 | ⋮foo: t | ||
327 | ⋮ | ||
328 | ⋮crate::foo | ||
329 | ⋮Baz: t v | ||
330 | "###); | ||
331 | } | ||
332 | |||
333 | #[test] | ||
334 | fn module_resolution_decl_inside_inline_module_with_path_attribute() { | ||
335 | let map = def_map( | ||
336 | r###" | ||
337 | //- /main.rs | ||
338 | #[path = "models"] | ||
339 | mod foo { | ||
340 | mod bar; | ||
341 | } | ||
342 | |||
343 | //- /models/bar.rs | ||
344 | pub struct Baz; | ||
345 | "###, | ||
346 | ); | ||
347 | |||
348 | assert_snapshot!(map, @r###" | ||
349 | ⋮crate | ||
350 | ⋮foo: t | ||
351 | ⋮ | ||
352 | ⋮crate::foo | ||
353 | ⋮bar: t | ||
354 | ⋮ | ||
355 | ⋮crate::foo::bar | ||
356 | ⋮Baz: t v | ||
357 | "###); | ||
358 | } | ||
359 | |||
360 | #[test] | ||
361 | fn module_resolution_decl_inside_inline_module() { | ||
362 | let map = def_map( | ||
363 | r###" | ||
364 | //- /main.rs | ||
365 | mod foo { | ||
366 | mod bar; | ||
367 | } | ||
368 | |||
369 | //- /foo/bar.rs | ||
370 | pub struct Baz; | ||
371 | "###, | ||
372 | ); | ||
373 | |||
374 | assert_snapshot!(map, @r###" | ||
375 | ⋮crate | ||
376 | ⋮foo: t | ||
377 | ⋮ | ||
378 | ⋮crate::foo | ||
379 | ⋮bar: t | ||
380 | ⋮ | ||
381 | ⋮crate::foo::bar | ||
382 | ⋮Baz: t v | ||
383 | "###); | ||
384 | } | ||
385 | |||
386 | #[test] | ||
387 | fn module_resolution_decl_inside_inline_module_2_with_path_attribute() { | ||
388 | let map = def_map( | ||
389 | r###" | ||
390 | //- /main.rs | ||
391 | #[path = "models/db"] | ||
392 | mod foo { | ||
393 | mod bar; | ||
394 | } | ||
395 | |||
396 | //- /models/db/bar.rs | ||
397 | pub struct Baz; | ||
398 | "###, | ||
399 | ); | ||
400 | |||
401 | assert_snapshot!(map, @r###" | ||
402 | ⋮crate | ||
403 | ⋮foo: t | ||
404 | ⋮ | ||
405 | ⋮crate::foo | ||
406 | ⋮bar: t | ||
407 | ⋮ | ||
408 | ⋮crate::foo::bar | ||
409 | ⋮Baz: t v | ||
410 | "###); | ||
411 | } | ||
412 | |||
413 | #[test] | ||
414 | fn module_resolution_decl_inside_inline_module_3() { | ||
415 | let map = def_map( | ||
416 | r###" | ||
417 | //- /main.rs | ||
418 | #[path = "models/db"] | ||
419 | mod foo { | ||
420 | #[path = "users.rs"] | ||
421 | mod bar; | ||
422 | } | ||
423 | |||
424 | //- /models/db/users.rs | ||
425 | pub struct Baz; | ||
426 | "###, | ||
427 | ); | ||
428 | |||
429 | assert_snapshot!(map, @r###" | ||
430 | ⋮crate | ||
431 | ⋮foo: t | ||
432 | ⋮ | ||
433 | ⋮crate::foo | ||
434 | ⋮bar: t | ||
435 | ⋮ | ||
436 | ⋮crate::foo::bar | ||
437 | ⋮Baz: t v | ||
438 | "###); | ||
439 | } | ||
440 | |||
441 | #[test] | ||
442 | fn module_resolution_decl_inside_inline_module_empty_path() { | ||
443 | let map = def_map( | ||
444 | r###" | ||
445 | //- /main.rs | ||
446 | #[path = ""] | ||
447 | mod foo { | ||
448 | #[path = "users.rs"] | ||
449 | mod bar; | ||
450 | } | ||
451 | |||
452 | //- /users.rs | ||
453 | pub struct Baz; | ||
454 | "###, | ||
455 | ); | ||
456 | |||
457 | assert_snapshot!(map, @r###" | ||
458 | ⋮crate | ||
459 | ⋮foo: t | ||
460 | ⋮ | ||
461 | ⋮crate::foo | ||
462 | ⋮bar: t | ||
463 | ⋮ | ||
464 | ⋮crate::foo::bar | ||
465 | ⋮Baz: t v | ||
466 | "###); | ||
467 | } | ||
468 | |||
469 | #[test] | ||
470 | fn module_resolution_decl_empty_path() { | ||
471 | let map = def_map( | ||
472 | r###" | ||
473 | //- /main.rs | ||
474 | #[path = ""] // Should try to read `/` (a directory) | ||
475 | mod foo; | ||
476 | |||
477 | //- /foo.rs | ||
478 | pub struct Baz; | ||
479 | "###, | ||
480 | ); | ||
481 | |||
482 | assert_snapshot!(map, @r###" | ||
483 | ⋮crate | ||
484 | "###); | ||
485 | } | ||
486 | |||
487 | #[test] | ||
488 | fn module_resolution_decl_inside_inline_module_relative_path() { | ||
489 | let map = def_map( | ||
490 | r###" | ||
491 | //- /main.rs | ||
492 | #[path = "./models"] | ||
493 | mod foo { | ||
494 | mod bar; | ||
495 | } | ||
496 | |||
497 | //- /models/bar.rs | ||
498 | pub struct Baz; | ||
499 | "###, | ||
500 | ); | ||
501 | |||
502 | assert_snapshot!(map, @r###" | ||
503 | ⋮crate | ||
504 | ⋮foo: t | ||
505 | ⋮ | ||
506 | ⋮crate::foo | ||
507 | ⋮bar: t | ||
508 | ⋮ | ||
509 | ⋮crate::foo::bar | ||
510 | ⋮Baz: t v | ||
511 | "###); | ||
512 | } | ||
513 | |||
514 | #[test] | ||
515 | fn module_resolution_decl_inside_inline_module_in_crate_root() { | ||
516 | let map = def_map( | ||
517 | r###" | ||
518 | //- /main.rs | ||
519 | mod foo { | ||
520 | #[path = "baz.rs"] | ||
521 | mod bar; | ||
522 | } | ||
523 | use self::foo::bar::Baz; | ||
524 | |||
525 | //- /foo/baz.rs | ||
526 | pub struct Baz; | ||
527 | "###, | ||
528 | ); | ||
529 | |||
530 | assert_snapshot!(map, @r###" | ||
531 | ⋮crate | ||
532 | ⋮Baz: t v | ||
533 | ⋮foo: t | ||
534 | ⋮ | ||
535 | ⋮crate::foo | ||
536 | ⋮bar: t | ||
537 | ⋮ | ||
538 | ⋮crate::foo::bar | ||
539 | ⋮Baz: t v | ||
540 | "###); | ||
541 | } | ||
542 | |||
543 | #[test] | ||
544 | fn module_resolution_decl_inside_inline_module_in_mod_rs() { | ||
545 | let map = def_map( | ||
546 | r###" | ||
547 | //- /main.rs | ||
548 | mod foo; | ||
549 | |||
550 | //- /foo/mod.rs | ||
551 | mod bar { | ||
552 | #[path = "qwe.rs"] | ||
553 | pub mod baz; | ||
554 | } | ||
555 | use self::bar::baz::Baz; | ||
556 | |||
557 | //- /foo/bar/qwe.rs | ||
558 | pub struct Baz; | ||
559 | "###, | ||
560 | ); | ||
561 | |||
562 | assert_snapshot!(map, @r###" | ||
563 | ⋮crate | ||
564 | ⋮foo: t | ||
565 | ⋮ | ||
566 | ⋮crate::foo | ||
567 | ⋮Baz: t v | ||
568 | ⋮bar: t | ||
569 | ⋮ | ||
570 | ⋮crate::foo::bar | ||
571 | ⋮baz: t | ||
572 | ⋮ | ||
573 | ⋮crate::foo::bar::baz | ||
574 | ⋮Baz: t v | ||
575 | "###); | ||
576 | } | ||
577 | |||
578 | #[test] | ||
579 | fn module_resolution_decl_inside_inline_module_in_non_crate_root() { | ||
580 | let map = def_map( | ||
581 | r###" | ||
582 | //- /main.rs | ||
583 | mod foo; | ||
584 | |||
585 | //- /foo.rs | ||
586 | mod bar { | ||
587 | #[path = "qwe.rs"] | ||
588 | pub mod baz; | ||
589 | } | ||
590 | use self::bar::baz::Baz; | ||
591 | |||
592 | //- /foo/bar/qwe.rs | ||
593 | pub struct Baz; | ||
594 | "###, | ||
595 | ); | ||
596 | |||
597 | assert_snapshot!(map, @r###" | ||
598 | ⋮crate | ||
599 | ⋮foo: t | ||
600 | ⋮ | ||
601 | ⋮crate::foo | ||
602 | ⋮Baz: t v | ||
603 | ⋮bar: t | ||
604 | ⋮ | ||
605 | ⋮crate::foo::bar | ||
606 | ⋮baz: t | ||
607 | ⋮ | ||
608 | ⋮crate::foo::bar::baz | ||
609 | ⋮Baz: t v | ||
610 | "###); | ||
611 | } | ||
612 | |||
613 | #[test] | ||
614 | fn module_resolution_decl_inside_inline_module_in_non_crate_root_2() { | ||
615 | let map = def_map( | ||
616 | r###" | ||
617 | //- /main.rs | ||
618 | mod foo; | ||
619 | |||
620 | //- /foo.rs | ||
621 | #[path = "bar"] | ||
622 | mod bar { | ||
623 | pub mod baz; | ||
624 | } | ||
625 | use self::bar::baz::Baz; | ||
626 | |||
627 | //- /bar/baz.rs | ||
628 | pub struct Baz; | ||
629 | "###, | ||
630 | ); | ||
631 | |||
632 | assert_snapshot!(map, @r###" | ||
633 | ⋮crate | ||
634 | ⋮foo: t | ||
635 | ⋮ | ||
636 | ⋮crate::foo | ||
637 | ⋮Baz: t v | ||
638 | ⋮bar: t | ||
639 | ⋮ | ||
640 | ⋮crate::foo::bar | ||
641 | ⋮baz: t | ||
642 | ⋮ | ||
643 | ⋮crate::foo::bar::baz | ||
644 | ⋮Baz: t v | ||
645 | "###); | ||
646 | } | ||
647 | |||
648 | #[test] | ||
649 | fn unresolved_module_diagnostics() { | ||
650 | let db = TestDB::with_files( | ||
651 | r" | ||
652 | //- /lib.rs | ||
653 | mod foo; | ||
654 | mod bar; | ||
655 | mod baz {} | ||
656 | //- /foo.rs | ||
657 | ", | ||
658 | ); | ||
659 | let krate = db.crate_graph().iter().next().unwrap(); | ||
660 | |||
661 | let crate_def_map = db.crate_def_map(krate); | ||
662 | |||
663 | insta::assert_debug_snapshot!( | ||
664 | crate_def_map.diagnostics, | ||
665 | @r###" | ||
666 | [ | ||
667 | UnresolvedModule { | ||
668 | module: CrateModuleId( | ||
669 | 0, | ||
670 | ), | ||
671 | declaration: AstId { | ||
672 | file_id: HirFileId( | ||
673 | FileId( | ||
674 | FileId( | ||
675 | 0, | ||
676 | ), | ||
677 | ), | ||
678 | ), | ||
679 | file_ast_id: FileAstId { | ||
680 | raw: ErasedFileAstId( | ||
681 | 1, | ||
682 | ), | ||
683 | _ty: PhantomData, | ||
684 | }, | ||
685 | }, | ||
686 | candidate: "bar.rs", | ||
687 | }, | ||
688 | ] | ||
689 | "### | ||
690 | ); | ||
691 | } | ||
692 | |||
693 | #[test] | ||
694 | fn module_resolution_decl_inside_module_in_non_crate_root_2() { | ||
695 | let map = def_map( | ||
696 | r###" | ||
697 | //- /main.rs | ||
698 | #[path="module/m2.rs"] | ||
699 | mod module; | ||
700 | |||
701 | //- /module/m2.rs | ||
702 | pub mod submod; | ||
703 | |||
704 | //- /module/submod.rs | ||
705 | pub struct Baz; | ||
706 | "###, | ||
707 | ); | ||
708 | |||
709 | assert_snapshot!(map, @r###" | ||
710 | ⋮crate | ||
711 | ⋮module: t | ||
712 | ⋮ | ||
713 | ⋮crate::module | ||
714 | ⋮submod: t | ||
715 | ⋮ | ||
716 | ⋮crate::module::submod | ||
717 | ⋮Baz: t v | ||
718 | "###); | ||
719 | } | ||
720 | |||
721 | #[test] | ||
722 | fn nested_out_of_line_module() { | ||
723 | let map = def_map( | ||
724 | r###" | ||
725 | //- /lib.rs | ||
726 | mod a { | ||
727 | mod b { | ||
728 | mod c; | ||
729 | } | ||
730 | } | ||
731 | |||
732 | //- /a/b/c.rs | ||
733 | struct X; | ||
734 | "###, | ||
735 | ); | ||
736 | |||
737 | assert_snapshot!(map, @r###" | ||
738 | crate | ||
739 | a: t | ||
740 | |||
741 | crate::a | ||
742 | b: t | ||
743 | |||
744 | crate::a::b | ||
745 | c: t | ||
746 | |||
747 | crate::a::b::c | ||
748 | X: t v | ||
749 | "###); | ||
750 | } | ||
751 | |||
752 | #[test] | ||
753 | fn nested_out_of_line_module_with_path() { | ||
754 | let map = def_map( | ||
755 | r###" | ||
756 | //- /lib.rs | ||
757 | mod a { | ||
758 | #[path = "d/e"] | ||
759 | mod b { | ||
760 | mod c; | ||
761 | } | ||
762 | } | ||
763 | |||
764 | //- /a/d/e/c.rs | ||
765 | struct X; | ||
766 | "###, | ||
767 | ); | ||
768 | |||
769 | assert_snapshot!(map, @r###" | ||
770 | crate | ||
771 | a: t | ||
772 | |||
773 | crate::a | ||
774 | b: t | ||
775 | |||
776 | crate::a::b | ||
777 | c: t | ||
778 | |||
779 | crate::a::b::c | ||
780 | X: t v | ||
781 | "###); | ||
782 | } | ||