aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_hir/src/nameres/tests.rs
diff options
context:
space:
mode:
Diffstat (limited to 'crates/ra_hir/src/nameres/tests.rs')
-rw-r--r--crates/ra_hir/src/nameres/tests.rs769
1 files changed, 0 insertions, 769 deletions
diff --git a/crates/ra_hir/src/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs
deleted file mode 100644
index 961e442a9..000000000
--- a/crates/ra_hir/src/nameres/tests.rs
+++ /dev/null
@@ -1,769 +0,0 @@
1use std::sync::Arc;
2
3use ra_db::SourceDatabase;
4use test_utils::{assert_eq_text, covers};
5
6use crate::{
7 ItemMap,
8 PersistentHirDatabase,
9 mock::MockDatabase,
10 nameres::crate_def_map::ModuleId,
11};
12use super::Resolution;
13
14fn item_map(fixture: &str) -> (Arc<ItemMap>, ModuleId) {
15 let (db, pos) = MockDatabase::with_position(fixture);
16 let module = crate::source_binder::module_from_position(&db, pos).unwrap();
17 let krate = module.krate(&db).unwrap();
18 let module_id = module.module_id;
19 (db.item_map(krate), module_id)
20}
21
22fn check_module_item_map(map: &ItemMap, module_id: ModuleId, expected: &str) {
23 let mut lines = map[module_id]
24 .items
25 .iter()
26 .map(|(name, res)| format!("{}: {}", name, dump_resolution(res)))
27 .collect::<Vec<_>>();
28 lines.sort();
29 let actual = lines.join("\n");
30 let expected = expected.trim().lines().map(|it| it.trim()).collect::<Vec<_>>().join("\n");
31 assert_eq_text!(&expected, &actual);
32
33 fn dump_resolution(resolution: &Resolution) -> &'static str {
34 match (resolution.def.types.is_some(), resolution.def.values.is_some()) {
35 (true, true) => "t v",
36 (true, false) => "t",
37 (false, true) => "v",
38 (false, false) => "_",
39 }
40 }
41}
42
43#[test]
44fn item_map_smoke_test() {
45 let (item_map, module_id) = item_map(
46 "
47 //- /lib.rs
48 mod foo;
49
50 use crate::foo::bar::Baz;
51 <|>
52
53 //- /foo/mod.rs
54 pub mod bar;
55
56 //- /foo/bar.rs
57 pub struct Baz;
58 ",
59 );
60 check_module_item_map(
61 &item_map,
62 module_id,
63 "
64 Baz: t v
65 foo: t
66 ",
67 );
68}
69
70#[test]
71fn use_as() {
72 let (item_map, module_id) = item_map(
73 "
74 //- /lib.rs
75 mod foo;
76
77 use crate::foo::Baz as Foo;
78 <|>
79
80 //- /foo/mod.rs
81 pub struct Baz;
82 ",
83 );
84 check_module_item_map(
85 &item_map,
86 module_id,
87 "
88 Foo: t v
89 foo: t
90 ",
91 );
92}
93
94#[test]
95fn use_trees() {
96 let (item_map, module_id) = item_map(
97 "
98 //- /lib.rs
99 mod foo;
100
101 use crate::foo::bar::{Baz, Quux};
102 <|>
103
104 //- /foo/mod.rs
105 pub mod bar;
106
107 //- /foo/bar.rs
108 pub struct Baz;
109 pub enum Quux {};
110 ",
111 );
112 check_module_item_map(
113 &item_map,
114 module_id,
115 "
116 Baz: t v
117 Quux: t
118 foo: t
119 ",
120 );
121}
122
123#[test]
124fn re_exports() {
125 let (item_map, module_id) = item_map(
126 "
127 //- /lib.rs
128 mod foo;
129
130 use self::foo::Baz;
131 <|>
132
133 //- /foo/mod.rs
134 pub mod bar;
135
136 pub use self::bar::Baz;
137
138 //- /foo/bar.rs
139 pub struct Baz;
140 ",
141 );
142 check_module_item_map(
143 &item_map,
144 module_id,
145 "
146 Baz: t v
147 foo: t
148 ",
149 );
150}
151
152#[test]
153fn glob_1() {
154 let (item_map, module_id) = item_map(
155 "
156 //- /lib.rs
157 mod foo;
158 use foo::*;
159 <|>
160
161 //- /foo/mod.rs
162 pub mod bar;
163 pub use self::bar::Baz;
164 pub struct Foo;
165
166 //- /foo/bar.rs
167 pub struct Baz;
168 ",
169 );
170 check_module_item_map(
171 &item_map,
172 module_id,
173 "
174 Baz: t v
175 Foo: t v
176 bar: t
177 foo: t
178 ",
179 );
180}
181
182#[test]
183fn glob_2() {
184 let (item_map, module_id) = item_map(
185 "
186 //- /lib.rs
187 mod foo;
188 use foo::*;
189 <|>
190
191 //- /foo/mod.rs
192 pub mod bar;
193 pub use self::bar::*;
194 pub struct Foo;
195
196 //- /foo/bar.rs
197 pub struct Baz;
198 pub use super::*;
199 ",
200 );
201 check_module_item_map(
202 &item_map,
203 module_id,
204 "
205 Baz: t v
206 Foo: t v
207 bar: t
208 foo: t
209 ",
210 );
211}
212
213#[test]
214fn glob_enum() {
215 covers!(glob_enum);
216 let (item_map, module_id) = item_map(
217 "
218 //- /lib.rs
219 enum Foo {
220 Bar, Baz
221 }
222 use self::Foo::*;
223 <|>
224 ",
225 );
226 check_module_item_map(
227 &item_map,
228 module_id,
229 "
230 Bar: t v
231 Baz: t v
232 Foo: t
233 ",
234 );
235}
236
237#[test]
238fn glob_across_crates() {
239 covers!(glob_across_crates);
240 let mut db = MockDatabase::with_files(
241 "
242 //- /main.rs
243 use test_crate::*;
244
245 //- /lib.rs
246 pub struct Baz;
247 ",
248 );
249 db.set_crate_graph_from_fixture(crate_graph! {
250 "main": ("/main.rs", ["test_crate"]),
251 "test_crate": ("/lib.rs", []),
252 });
253 let main_id = db.file_id_of("/main.rs");
254
255 let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
256 let krate = module.krate(&db).unwrap();
257 let item_map = db.item_map(krate);
258
259 check_module_item_map(
260 &item_map,
261 module.module_id,
262 "
263 Baz: t v
264 ",
265 );
266}
267
268#[test]
269fn edition_2015_imports() {
270 let mut db = MockDatabase::with_files(
271 "
272 //- /main.rs
273 mod foo;
274 mod bar;
275
276 //- /bar.rs
277 struct Bar;
278
279 //- /foo.rs
280 use bar::Bar;
281 use other_crate::FromLib;
282
283 //- /lib.rs
284 struct FromLib;
285 ",
286 );
287 db.set_crate_graph_from_fixture(crate_graph! {
288 "main": ("/main.rs", "2015", ["other_crate"]),
289 "other_crate": ("/lib.rs", "2018", []),
290 });
291 let foo_id = db.file_id_of("/foo.rs");
292
293 let module = crate::source_binder::module_from_file_id(&db, foo_id).unwrap();
294 let krate = module.krate(&db).unwrap();
295 let item_map = db.item_map(krate);
296
297 check_module_item_map(
298 &item_map,
299 module.module_id,
300 "
301 Bar: t v
302 FromLib: t v
303 ",
304 );
305}
306
307#[test]
308fn module_resolution_works_for_non_standard_filenames() {
309 let mut db = MockDatabase::with_files(
310 "
311 //- /my_library.rs
312 mod foo;
313 use self::foo::Bar;
314
315 //- /foo/mod.rs
316 pub struct Bar;
317 ",
318 );
319 db.set_crate_graph_from_fixture(crate_graph! {
320 "my_library": ("/my_library.rs", []),
321 });
322 let file_id = db.file_id_of("/my_library.rs");
323
324 let module = crate::source_binder::module_from_file_id(&db, file_id).unwrap();
325 let krate = module.krate(&db).unwrap();
326 let module_id = module.module_id;
327 let item_map = db.item_map(krate);
328 check_module_item_map(
329 &item_map,
330 module_id,
331 "
332 Bar: t v
333 foo: t
334 ",
335 );
336}
337
338#[test]
339fn std_prelude() {
340 covers!(std_prelude);
341 let mut db = MockDatabase::with_files(
342 "
343 //- /main.rs
344 use Foo::*;
345
346 //- /lib.rs
347 mod prelude;
348 #[prelude_import]
349 use prelude::*;
350
351 //- /prelude.rs
352 pub enum Foo { Bar, Baz };
353 ",
354 );
355 db.set_crate_graph_from_fixture(crate_graph! {
356 "main": ("/main.rs", ["test_crate"]),
357 "test_crate": ("/lib.rs", []),
358 });
359 let main_id = db.file_id_of("/main.rs");
360
361 let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
362 eprintln!("module = {:?}", module);
363 let krate = module.krate(&db).unwrap();
364 let item_map = db.item_map(krate);
365
366 check_module_item_map(
367 &item_map,
368 module.module_id,
369 "
370 Bar: t v
371 Baz: t v
372 ",
373 );
374}
375
376#[test]
377fn name_res_works_for_broken_modules() {
378 covers!(name_res_works_for_broken_modules);
379 let (item_map, module_id) = item_map(
380 "
381 //- /lib.rs
382 mod foo // no `;`, no body
383
384 use self::foo::Baz;
385 <|>
386
387 //- /foo/mod.rs
388 pub mod bar;
389
390 pub use self::bar::Baz;
391
392 //- /foo/bar.rs
393 pub struct Baz;
394 ",
395 );
396 check_module_item_map(
397 &item_map,
398 module_id,
399 "
400 Baz: _
401 ",
402 );
403}
404
405#[test]
406fn item_map_using_self() {
407 let (item_map, module_id) = item_map(
408 "
409 //- /lib.rs
410 mod foo;
411 use crate::foo::bar::Baz::{self};
412 <|>
413 //- /foo/mod.rs
414 pub mod bar;
415 //- /foo/bar.rs
416 pub struct Baz;
417 ",
418 );
419 check_module_item_map(
420 &item_map,
421 module_id,
422 "
423 Baz: t v
424 foo: t
425 ",
426 );
427}
428
429#[test]
430fn item_map_enum_importing() {
431 covers!(item_map_enum_importing);
432 let (item_map, module_id) = item_map(
433 "
434 //- /lib.rs
435 enum E { V }
436 use self::E::V;
437 <|>
438 ",
439 );
440 check_module_item_map(
441 &item_map,
442 module_id,
443 "
444 E: t
445 V: t v
446 ",
447 );
448}
449
450#[test]
451fn item_map_across_crates() {
452 let mut db = MockDatabase::with_files(
453 "
454 //- /main.rs
455 use test_crate::Baz;
456
457 //- /lib.rs
458 pub struct Baz;
459 ",
460 );
461 db.set_crate_graph_from_fixture(crate_graph! {
462 "main": ("/main.rs", ["test_crate"]),
463 "test_crate": ("/lib.rs", []),
464 });
465 let main_id = db.file_id_of("/main.rs");
466
467 let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
468 let krate = module.krate(&db).unwrap();
469 let item_map = db.item_map(krate);
470
471 check_module_item_map(
472 &item_map,
473 module.module_id,
474 "
475 Baz: t v
476 ",
477 );
478}
479
480#[test]
481fn extern_crate_rename() {
482 let mut db = MockDatabase::with_files(
483 "
484 //- /main.rs
485 extern crate alloc as alloc_crate;
486
487 mod alloc;
488 mod sync;
489
490 //- /sync.rs
491 use alloc_crate::Arc;
492
493 //- /lib.rs
494 struct Arc;
495 ",
496 );
497 db.set_crate_graph_from_fixture(crate_graph! {
498 "main": ("/main.rs", ["alloc"]),
499 "alloc": ("/lib.rs", []),
500 });
501 let sync_id = db.file_id_of("/sync.rs");
502
503 let module = crate::source_binder::module_from_file_id(&db, sync_id).unwrap();
504 let krate = module.krate(&db).unwrap();
505 let item_map = db.item_map(krate);
506
507 check_module_item_map(
508 &item_map,
509 module.module_id,
510 "
511 Arc: t v
512 ",
513 );
514}
515
516#[test]
517fn extern_crate_rename_2015_edition() {
518 let mut db = MockDatabase::with_files(
519 "
520 //- /main.rs
521 extern crate alloc as alloc_crate;
522
523 mod alloc;
524 mod sync;
525
526 //- /sync.rs
527 use alloc_crate::Arc;
528
529 //- /lib.rs
530 struct Arc;
531 ",
532 );
533 db.set_crate_graph_from_fixture(crate_graph! {
534 "main": ("/main.rs", "2015", ["alloc"]),
535 "alloc": ("/lib.rs", []),
536 });
537 let sync_id = db.file_id_of("/sync.rs");
538
539 let module = crate::source_binder::module_from_file_id(&db, sync_id).unwrap();
540 let krate = module.krate(&db).unwrap();
541 let item_map = db.item_map(krate);
542
543 check_module_item_map(
544 &item_map,
545 module.module_id,
546 "
547 Arc: t v
548 ",
549 );
550}
551
552#[test]
553fn import_across_source_roots() {
554 let mut db = MockDatabase::with_files(
555 "
556 //- /lib.rs
557 pub mod a {
558 pub mod b {
559 pub struct C;
560 }
561 }
562
563 //- root /main/
564
565 //- /main/main.rs
566 use test_crate::a::b::C;
567 ",
568 );
569 db.set_crate_graph_from_fixture(crate_graph! {
570 "main": ("/main/main.rs", ["test_crate"]),
571 "test_crate": ("/lib.rs", []),
572 });
573 let main_id = db.file_id_of("/main/main.rs");
574
575 let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
576 let krate = module.krate(&db).unwrap();
577 let item_map = db.item_map(krate);
578
579 check_module_item_map(
580 &item_map,
581 module.module_id,
582 "
583 C: t v
584 ",
585 );
586}
587
588#[test]
589fn reexport_across_crates() {
590 let mut db = MockDatabase::with_files(
591 "
592 //- /main.rs
593 use test_crate::Baz;
594
595 //- /lib.rs
596 pub use foo::Baz;
597
598 mod foo;
599
600 //- /foo.rs
601 pub struct Baz;
602 ",
603 );
604 db.set_crate_graph_from_fixture(crate_graph! {
605 "main": ("/main.rs", ["test_crate"]),
606 "test_crate": ("/lib.rs", []),
607 });
608 let main_id = db.file_id_of("/main.rs");
609
610 let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
611 let krate = module.krate(&db).unwrap();
612 let item_map = db.item_map(krate);
613
614 check_module_item_map(
615 &item_map,
616 module.module_id,
617 "
618 Baz: t v
619 ",
620 );
621}
622
623#[test]
624fn values_dont_shadow_extern_crates() {
625 let mut db = MockDatabase::with_files(
626 "
627 //- /main.rs
628 fn foo() {}
629 use foo::Bar;
630
631 //- /foo/lib.rs
632 pub struct Bar;
633 ",
634 );
635 db.set_crate_graph_from_fixture(crate_graph! {
636 "main": ("/main.rs", ["foo"]),
637 "foo": ("/foo/lib.rs", []),
638 });
639 let main_id = db.file_id_of("/main.rs");
640
641 let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
642 let krate = module.krate(&db).unwrap();
643 let item_map = db.item_map(krate);
644
645 check_module_item_map(
646 &item_map,
647 module.module_id,
648 "
649 Bar: t v
650 foo: v
651 ",
652 );
653}
654
655fn check_item_map_is_not_recomputed(initial: &str, file_change: &str) {
656 let (mut db, pos) = MockDatabase::with_position(initial);
657 let module = crate::source_binder::module_from_file_id(&db, pos.file_id).unwrap();
658 let krate = module.krate(&db).unwrap();
659 {
660 let events = db.log_executed(|| {
661 db.item_map(krate);
662 });
663 assert!(format!("{:?}", events).contains("item_map"))
664 }
665 db.set_file_text(pos.file_id, Arc::new(file_change.to_string()));
666
667 {
668 let events = db.log_executed(|| {
669 db.item_map(krate);
670 });
671 assert!(!format!("{:?}", events).contains("item_map"), "{:#?}", events)
672 }
673}
674
675#[test]
676fn typing_inside_a_function_should_not_invalidate_item_map() {
677 check_item_map_is_not_recomputed(
678 "
679 //- /lib.rs
680 mod foo;<|>
681
682 use crate::foo::bar::Baz;
683
684 fn foo() -> i32 {
685 1 + 1
686 }
687 //- /foo/mod.rs
688 pub mod bar;
689
690 //- /foo/bar.rs
691 pub struct Baz;
692 ",
693 "
694 mod foo;
695
696 use crate::foo::bar::Baz;
697
698 fn foo() -> i32 { 92 }
699 ",
700 );
701}
702
703#[test]
704fn adding_inner_items_should_not_invalidate_item_map() {
705 check_item_map_is_not_recomputed(
706 "
707 //- /lib.rs
708 struct S { a: i32}
709 enum E { A }
710 trait T {
711 fn a() {}
712 }
713 mod foo;<|>
714 impl S {
715 fn a() {}
716 }
717 use crate::foo::bar::Baz;
718 //- /foo/mod.rs
719 pub mod bar;
720
721 //- /foo/bar.rs
722 pub struct Baz;
723 ",
724 "
725 struct S { a: i32, b: () }
726 enum E { A, B }
727 trait T {
728 fn a() {}
729 fn b() {}
730 }
731 mod foo;<|>
732 impl S {
733 fn a() {}
734 fn b() {}
735 }
736 use crate::foo::bar::Baz;
737 ",
738 );
739}
740
741#[test]
742fn typing_inside_a_function_inside_a_macro_should_not_invalidate_item_map() {
743 check_item_map_is_not_recomputed(
744 "
745 //- /lib.rs
746 mod foo;
747
748 use crate::foo::bar::Baz;
749
750 //- /foo/mod.rs
751 pub mod bar;
752
753 //- /foo/bar.rs
754 <|>
755 salsa::query_group! {
756 trait Baz {
757 fn foo() -> i32 { 1 + 1 }
758 }
759 }
760 ",
761 "
762 salsa::query_group! {
763 trait Baz {
764 fn foo() -> i32 { 92 }
765 }
766 }
767 ",
768 );
769}
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-29 18:19:41 +0100