diff options
author | Aleksey Kladov <[email protected]> | 2019-03-14 08:53:40 +0000 |
---|---|---|
committer | Aleksey Kladov <[email protected]> | 2019-03-17 09:49:07 +0000 |
commit | 71e5adf694a4b253bc5bb48be96bb6ba08002d8c (patch) | |
tree | 27208afed0ec41b07f8fffa05659259f13fc027c /crates/ra_hir/src/nameres/tests.rs | |
parent | 2195d1db6d70d64383bec82819fab02891d09744 (diff) |
move tests over to crate-def-map
Diffstat (limited to 'crates/ra_hir/src/nameres/tests.rs')
-rw-r--r-- | crates/ra_hir/src/nameres/tests.rs | 769 |
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 @@ | |||
1 | use std::sync::Arc; | ||
2 | |||
3 | use ra_db::SourceDatabase; | ||
4 | use test_utils::{assert_eq_text, covers}; | ||
5 | |||
6 | use crate::{ | ||
7 | ItemMap, | ||
8 | PersistentHirDatabase, | ||
9 | mock::MockDatabase, | ||
10 | nameres::crate_def_map::ModuleId, | ||
11 | }; | ||
12 | use super::Resolution; | ||
13 | |||
14 | fn 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 | |||
22 | fn 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] | ||
44 | fn 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] | ||
71 | fn 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] | ||
95 | fn 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] | ||
124 | fn 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] | ||
153 | fn 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] | ||
183 | fn 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] | ||
214 | fn 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] | ||
238 | fn 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] | ||
269 | fn 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] | ||
308 | fn 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] | ||
339 | fn 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] | ||
377 | fn 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] | ||
406 | fn 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] | ||
430 | fn 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] | ||
451 | fn 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] | ||
481 | fn 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] | ||
517 | fn 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] | ||
553 | fn 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] | ||
589 | fn 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] | ||
624 | fn 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 | |||
655 | fn 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] | ||
676 | fn 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] | ||
704 | fn 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] | ||
742 | fn 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 | } | ||