diff options
Diffstat (limited to 'crates/ra_hir_ty/src/tests')
-rw-r--r-- | crates/ra_hir_ty/src/tests/coercion.rs | 3 | ||||
-rw-r--r-- | crates/ra_hir_ty/src/tests/display_source_code.rs | 49 | ||||
-rw-r--r-- | crates/ra_hir_ty/src/tests/macros.rs | 116 | ||||
-rw-r--r-- | crates/ra_hir_ty/src/tests/method_resolution.rs | 158 | ||||
-rw-r--r-- | crates/ra_hir_ty/src/tests/never_type.rs | 118 | ||||
-rw-r--r-- | crates/ra_hir_ty/src/tests/regression.rs | 21 | ||||
-rw-r--r-- | crates/ra_hir_ty/src/tests/simple.rs | 135 | ||||
-rw-r--r-- | crates/ra_hir_ty/src/tests/traits.rs | 342 |
8 files changed, 396 insertions, 546 deletions
diff --git a/crates/ra_hir_ty/src/tests/coercion.rs b/crates/ra_hir_ty/src/tests/coercion.rs index 5a1c6ccc3..136d28a91 100644 --- a/crates/ra_hir_ty/src/tests/coercion.rs +++ b/crates/ra_hir_ty/src/tests/coercion.rs | |||
@@ -1,7 +1,8 @@ | |||
1 | use super::infer_with_mismatches; | ||
2 | use insta::assert_snapshot; | 1 | use insta::assert_snapshot; |
3 | use test_utils::mark; | 2 | use test_utils::mark; |
4 | 3 | ||
4 | use super::infer_with_mismatches; | ||
5 | |||
5 | // Infer with some common definitions and impls. | 6 | // Infer with some common definitions and impls. |
6 | fn infer(source: &str) -> String { | 7 | fn infer(source: &str) -> String { |
7 | let defs = r#" | 8 | let defs = r#" |
diff --git a/crates/ra_hir_ty/src/tests/display_source_code.rs b/crates/ra_hir_ty/src/tests/display_source_code.rs index 5dfa0a014..b502135d8 100644 --- a/crates/ra_hir_ty/src/tests/display_source_code.rs +++ b/crates/ra_hir_ty/src/tests/display_source_code.rs | |||
@@ -1,50 +1,41 @@ | |||
1 | use super::displayed_source_at_pos; | 1 | use super::check_types_source_code; |
2 | use crate::test_db::TestDB; | ||
3 | use ra_db::fixture::WithFixture; | ||
4 | 2 | ||
5 | #[test] | 3 | #[test] |
6 | fn qualify_path_to_submodule() { | 4 | fn qualify_path_to_submodule() { |
7 | let (db, pos) = TestDB::with_position( | 5 | check_types_source_code( |
8 | r#" | 6 | r#" |
9 | //- /main.rs | ||
10 | |||
11 | mod foo { | 7 | mod foo { |
12 | pub struct Foo; | 8 | pub struct Foo; |
13 | } | 9 | } |
14 | 10 | ||
15 | fn bar() { | 11 | fn bar() { |
16 | let foo: foo::Foo = foo::Foo; | 12 | let foo: foo::Foo = foo::Foo; |
17 | foo<|> | 13 | foo |
18 | } | 14 | } //^ foo::Foo |
19 | 15 | ||
20 | "#, | 16 | "#, |
21 | ); | 17 | ); |
22 | assert_eq!("foo::Foo", displayed_source_at_pos(&db, pos)); | ||
23 | } | 18 | } |
24 | 19 | ||
25 | #[test] | 20 | #[test] |
26 | fn omit_default_type_parameters() { | 21 | fn omit_default_type_parameters() { |
27 | let (db, pos) = TestDB::with_position( | 22 | check_types_source_code( |
28 | r" | 23 | r#" |
29 | //- /main.rs | 24 | struct Foo<T = u8> { t: T } |
30 | struct Foo<T = u8> { t: T } | 25 | fn main() { |
31 | fn main() { | 26 | let foo = Foo { t: 5u8 }; |
32 | let foo = Foo { t: 5u8 }; | 27 | foo; |
33 | foo<|>; | 28 | } //^ Foo |
34 | } | 29 | "#, |
35 | ", | ||
36 | ); | 30 | ); |
37 | assert_eq!("Foo", displayed_source_at_pos(&db, pos)); | ||
38 | 31 | ||
39 | let (db, pos) = TestDB::with_position( | 32 | check_types_source_code( |
40 | r" | 33 | r#" |
41 | //- /main.rs | 34 | struct Foo<K, T = u8> { k: K, t: T } |
42 | struct Foo<K, T = u8> { k: K, t: T } | 35 | fn main() { |
43 | fn main() { | 36 | let foo = Foo { k: 400, t: 5u8 }; |
44 | let foo = Foo { k: 400, t: 5u8 }; | 37 | foo; |
45 | foo<|>; | 38 | } //^ Foo<i32> |
46 | } | 39 | "#, |
47 | ", | ||
48 | ); | 40 | ); |
49 | assert_eq!("Foo<i32>", displayed_source_at_pos(&db, pos)); | ||
50 | } | 41 | } |
diff --git a/crates/ra_hir_ty/src/tests/macros.rs b/crates/ra_hir_ty/src/tests/macros.rs index be2b48dcc..45c4e309e 100644 --- a/crates/ra_hir_ty/src/tests/macros.rs +++ b/crates/ra_hir_ty/src/tests/macros.rs | |||
@@ -1,16 +1,13 @@ | |||
1 | use std::fs; | 1 | use std::fs; |
2 | 2 | ||
3 | use insta::assert_snapshot; | 3 | use insta::assert_snapshot; |
4 | use ra_db::fixture::WithFixture; | ||
5 | use test_utils::project_dir; | 4 | use test_utils::project_dir; |
6 | 5 | ||
7 | use crate::test_db::TestDB; | 6 | use super::{check_types, infer}; |
8 | |||
9 | use super::{infer, type_at, type_at_pos}; | ||
10 | 7 | ||
11 | #[test] | 8 | #[test] |
12 | fn cfg_impl_def() { | 9 | fn cfg_impl_def() { |
13 | let (db, pos) = TestDB::with_position( | 10 | check_types( |
14 | r#" | 11 | r#" |
15 | //- /main.rs crate:main deps:foo cfg:test | 12 | //- /main.rs crate:main deps:foo cfg:test |
16 | use foo::S as T; | 13 | use foo::S as T; |
@@ -28,8 +25,8 @@ impl S { | |||
28 | 25 | ||
29 | fn test() { | 26 | fn test() { |
30 | let t = (S.foo1(), S.foo2(), T.foo3(), T.foo4()); | 27 | let t = (S.foo1(), S.foo2(), T.foo3(), T.foo4()); |
31 | t<|>; | 28 | t; |
32 | } | 29 | } //^ (i32, {unknown}, i32, {unknown}) |
33 | 30 | ||
34 | //- /foo.rs crate:foo | 31 | //- /foo.rs crate:foo |
35 | struct S; | 32 | struct S; |
@@ -45,7 +42,6 @@ impl S { | |||
45 | } | 42 | } |
46 | "#, | 43 | "#, |
47 | ); | 44 | ); |
48 | assert_eq!("(i32, {unknown}, i32, {unknown})", type_at_pos(&db, pos)); | ||
49 | } | 45 | } |
50 | 46 | ||
51 | #[test] | 47 | #[test] |
@@ -253,26 +249,24 @@ fn foo() { | |||
253 | 249 | ||
254 | #[test] | 250 | #[test] |
255 | fn processes_impls_generated_by_macros() { | 251 | fn processes_impls_generated_by_macros() { |
256 | let t = type_at( | 252 | check_types( |
257 | r#" | 253 | r#" |
258 | //- /main.rs | ||
259 | macro_rules! m { | 254 | macro_rules! m { |
260 | ($ident:ident) => (impl Trait for $ident {}) | 255 | ($ident:ident) => (impl Trait for $ident {}) |
261 | } | 256 | } |
262 | trait Trait { fn foo(self) -> u128 {} } | 257 | trait Trait { fn foo(self) -> u128 {} } |
263 | struct S; | 258 | struct S; |
264 | m!(S); | 259 | m!(S); |
265 | fn test() { S.foo()<|>; } | 260 | fn test() { S.foo(); } |
261 | //^ u128 | ||
266 | "#, | 262 | "#, |
267 | ); | 263 | ); |
268 | assert_eq!(t, "u128"); | ||
269 | } | 264 | } |
270 | 265 | ||
271 | #[test] | 266 | #[test] |
272 | fn infer_assoc_items_generated_by_macros() { | 267 | fn infer_assoc_items_generated_by_macros() { |
273 | let t = type_at( | 268 | check_types( |
274 | r#" | 269 | r#" |
275 | //- /main.rs | ||
276 | macro_rules! m { | 270 | macro_rules! m { |
277 | () => (fn foo(&self) -> u128 {0}) | 271 | () => (fn foo(&self) -> u128 {0}) |
278 | } | 272 | } |
@@ -281,17 +275,16 @@ impl S { | |||
281 | m!(); | 275 | m!(); |
282 | } | 276 | } |
283 | 277 | ||
284 | fn test() { S.foo()<|>; } | 278 | fn test() { S.foo(); } |
279 | //^ u128 | ||
285 | "#, | 280 | "#, |
286 | ); | 281 | ); |
287 | assert_eq!(t, "u128"); | ||
288 | } | 282 | } |
289 | 283 | ||
290 | #[test] | 284 | #[test] |
291 | fn infer_assoc_items_generated_by_macros_chain() { | 285 | fn infer_assoc_items_generated_by_macros_chain() { |
292 | let t = type_at( | 286 | check_types( |
293 | r#" | 287 | r#" |
294 | //- /main.rs | ||
295 | macro_rules! m_inner { | 288 | macro_rules! m_inner { |
296 | () => {fn foo(&self) -> u128 {0}} | 289 | () => {fn foo(&self) -> u128 {0}} |
297 | } | 290 | } |
@@ -304,21 +297,21 @@ impl S { | |||
304 | m!(); | 297 | m!(); |
305 | } | 298 | } |
306 | 299 | ||
307 | fn test() { S.foo()<|>; } | 300 | fn test() { S.foo(); } |
301 | //^ u128 | ||
308 | "#, | 302 | "#, |
309 | ); | 303 | ); |
310 | assert_eq!(t, "u128"); | ||
311 | } | 304 | } |
312 | 305 | ||
313 | #[test] | 306 | #[test] |
314 | fn infer_macro_with_dollar_crate_is_correct_in_expr() { | 307 | fn infer_macro_with_dollar_crate_is_correct_in_expr() { |
315 | let (db, pos) = TestDB::with_position( | 308 | check_types( |
316 | r#" | 309 | r#" |
317 | //- /main.rs crate:main deps:foo | 310 | //- /main.rs crate:main deps:foo |
318 | fn test() { | 311 | fn test() { |
319 | let x = (foo::foo!(1), foo::foo!(2)); | 312 | let x = (foo::foo!(1), foo::foo!(2)); |
320 | x<|>; | 313 | x; |
321 | } | 314 | } //^ (i32, usize) |
322 | 315 | ||
323 | //- /lib.rs crate:foo | 316 | //- /lib.rs crate:foo |
324 | #[macro_export] | 317 | #[macro_export] |
@@ -335,12 +328,11 @@ macro_rules! bar { | |||
335 | pub fn baz() -> usize { 31usize } | 328 | pub fn baz() -> usize { 31usize } |
336 | "#, | 329 | "#, |
337 | ); | 330 | ); |
338 | assert_eq!("(i32, usize)", type_at_pos(&db, pos)); | ||
339 | } | 331 | } |
340 | 332 | ||
341 | #[test] | 333 | #[test] |
342 | fn infer_macro_with_dollar_crate_is_correct_in_trait_associate_type() { | 334 | fn infer_macro_with_dollar_crate_is_correct_in_trait_associate_type() { |
343 | let (db, pos) = TestDB::with_position( | 335 | check_types( |
344 | r#" | 336 | r#" |
345 | //- /main.rs crate:main deps:foo | 337 | //- /main.rs crate:main deps:foo |
346 | use foo::Trait; | 338 | use foo::Trait; |
@@ -348,7 +340,8 @@ use foo::Trait; | |||
348 | fn test() { | 340 | fn test() { |
349 | let msg = foo::Message(foo::MessageRef); | 341 | let msg = foo::Message(foo::MessageRef); |
350 | let r = msg.deref(); | 342 | let r = msg.deref(); |
351 | r<|>; | 343 | r; |
344 | //^ &MessageRef | ||
352 | } | 345 | } |
353 | 346 | ||
354 | //- /lib.rs crate:foo | 347 | //- /lib.rs crate:foo |
@@ -375,7 +368,6 @@ macro_rules! expand { | |||
375 | expand!(); | 368 | expand!(); |
376 | "#, | 369 | "#, |
377 | ); | 370 | ); |
378 | assert_eq!("&MessageRef", type_at_pos(&db, pos)); | ||
379 | } | 371 | } |
380 | 372 | ||
381 | #[test] | 373 | #[test] |
@@ -429,13 +421,13 @@ fn main() { | |||
429 | 421 | ||
430 | #[test] | 422 | #[test] |
431 | fn infer_local_inner_macros() { | 423 | fn infer_local_inner_macros() { |
432 | let (db, pos) = TestDB::with_position( | 424 | check_types( |
433 | r#" | 425 | r#" |
434 | //- /main.rs crate:main deps:foo | 426 | //- /main.rs crate:main deps:foo |
435 | fn test() { | 427 | fn test() { |
436 | let x = foo::foo!(1); | 428 | let x = foo::foo!(1); |
437 | x<|>; | 429 | x; |
438 | } | 430 | } //^ i32 |
439 | 431 | ||
440 | //- /lib.rs crate:foo | 432 | //- /lib.rs crate:foo |
441 | #[macro_export(local_inner_macros)] | 433 | #[macro_export(local_inner_macros)] |
@@ -450,7 +442,6 @@ macro_rules! bar { | |||
450 | 442 | ||
451 | "#, | 443 | "#, |
452 | ); | 444 | ); |
453 | assert_eq!("i32", type_at_pos(&db, pos)); | ||
454 | } | 445 | } |
455 | 446 | ||
456 | #[test] | 447 | #[test] |
@@ -531,7 +522,7 @@ fn main() { | |||
531 | 522 | ||
532 | #[test] | 523 | #[test] |
533 | fn infer_builtin_macros_include() { | 524 | fn infer_builtin_macros_include() { |
534 | let (db, pos) = TestDB::with_position( | 525 | check_types( |
535 | r#" | 526 | r#" |
536 | //- /main.rs | 527 | //- /main.rs |
537 | #[rustc_builtin_macro] | 528 | #[rustc_builtin_macro] |
@@ -540,14 +531,13 @@ macro_rules! include {() => {}} | |||
540 | include!("foo.rs"); | 531 | include!("foo.rs"); |
541 | 532 | ||
542 | fn main() { | 533 | fn main() { |
543 | bar()<|>; | 534 | bar(); |
544 | } | 535 | } //^ u32 |
545 | 536 | ||
546 | //- /foo.rs | 537 | //- /foo.rs |
547 | fn bar() -> u32 {0} | 538 | fn bar() -> u32 {0} |
548 | "#, | 539 | "#, |
549 | ); | 540 | ); |
550 | assert_eq!("u32", type_at_pos(&db, pos)); | ||
551 | } | 541 | } |
552 | 542 | ||
553 | #[test] | 543 | #[test] |
@@ -565,18 +555,17 @@ macro_rules! include {() => {}} | |||
565 | include!("foo.rs"); | 555 | include!("foo.rs"); |
566 | 556 | ||
567 | fn main() { | 557 | fn main() { |
568 | RegisterBlock { }<|>; | 558 | RegisterBlock { }; |
559 | //^ RegisterBlock | ||
569 | } | 560 | } |
570 | "#; | 561 | "#; |
571 | let fixture = format!("{}\n//- /foo.rs\n{}", fixture, big_file); | 562 | let fixture = format!("{}\n//- /foo.rs\n{}", fixture, big_file); |
572 | 563 | check_types(&fixture); | |
573 | let (db, pos) = TestDB::with_position(&fixture); | ||
574 | assert_eq!("RegisterBlock", type_at_pos(&db, pos)); | ||
575 | } | 564 | } |
576 | 565 | ||
577 | #[test] | 566 | #[test] |
578 | fn infer_builtin_macros_include_concat() { | 567 | fn infer_builtin_macros_include_concat() { |
579 | let (db, pos) = TestDB::with_position( | 568 | check_types( |
580 | r#" | 569 | r#" |
581 | //- /main.rs | 570 | //- /main.rs |
582 | #[rustc_builtin_macro] | 571 | #[rustc_builtin_macro] |
@@ -588,19 +577,18 @@ macro_rules! concat {() => {}} | |||
588 | include!(concat!("f", "oo.rs")); | 577 | include!(concat!("f", "oo.rs")); |
589 | 578 | ||
590 | fn main() { | 579 | fn main() { |
591 | bar()<|>; | 580 | bar(); |
592 | } | 581 | } //^ u32 |
593 | 582 | ||
594 | //- /foo.rs | 583 | //- /foo.rs |
595 | fn bar() -> u32 {0} | 584 | fn bar() -> u32 {0} |
596 | "#, | 585 | "#, |
597 | ); | 586 | ); |
598 | assert_eq!("u32", type_at_pos(&db, pos)); | ||
599 | } | 587 | } |
600 | 588 | ||
601 | #[test] | 589 | #[test] |
602 | fn infer_builtin_macros_include_concat_with_bad_env_should_failed() { | 590 | fn infer_builtin_macros_include_concat_with_bad_env_should_failed() { |
603 | let (db, pos) = TestDB::with_position( | 591 | check_types( |
604 | r#" | 592 | r#" |
605 | //- /main.rs | 593 | //- /main.rs |
606 | #[rustc_builtin_macro] | 594 | #[rustc_builtin_macro] |
@@ -615,32 +603,29 @@ macro_rules! env {() => {}} | |||
615 | include!(concat!(env!("OUT_DIR"), "/foo.rs")); | 603 | include!(concat!(env!("OUT_DIR"), "/foo.rs")); |
616 | 604 | ||
617 | fn main() { | 605 | fn main() { |
618 | bar()<|>; | 606 | bar(); |
619 | } | 607 | } //^ {unknown} |
620 | 608 | ||
621 | //- /foo.rs | 609 | //- /foo.rs |
622 | fn bar() -> u32 {0} | 610 | fn bar() -> u32 {0} |
623 | "#, | 611 | "#, |
624 | ); | 612 | ); |
625 | assert_eq!("{unknown}", type_at_pos(&db, pos)); | ||
626 | } | 613 | } |
627 | 614 | ||
628 | #[test] | 615 | #[test] |
629 | fn infer_builtin_macros_include_itself_should_failed() { | 616 | fn infer_builtin_macros_include_itself_should_failed() { |
630 | let (db, pos) = TestDB::with_position( | 617 | check_types( |
631 | r#" | 618 | r#" |
632 | //- /main.rs | ||
633 | #[rustc_builtin_macro] | 619 | #[rustc_builtin_macro] |
634 | macro_rules! include {() => {}} | 620 | macro_rules! include {() => {}} |
635 | 621 | ||
636 | include!("main.rs"); | 622 | include!("main.rs"); |
637 | 623 | ||
638 | fn main() { | 624 | fn main() { |
639 | 0<|> | 625 | 0 |
640 | } | 626 | } //^ i32 |
641 | "#, | 627 | "#, |
642 | ); | 628 | ); |
643 | assert_eq!("i32", type_at_pos(&db, pos)); | ||
644 | } | 629 | } |
645 | 630 | ||
646 | #[test] | 631 | #[test] |
@@ -686,14 +671,14 @@ fn main() { | |||
686 | 671 | ||
687 | #[test] | 672 | #[test] |
688 | fn infer_derive_clone_simple() { | 673 | fn infer_derive_clone_simple() { |
689 | let (db, pos) = TestDB::with_position( | 674 | check_types( |
690 | r#" | 675 | r#" |
691 | //- /main.rs crate:main deps:core | 676 | //- /main.rs crate:main deps:core |
692 | #[derive(Clone)] | 677 | #[derive(Clone)] |
693 | struct S; | 678 | struct S; |
694 | fn test() { | 679 | fn test() { |
695 | S.clone()<|>; | 680 | S.clone(); |
696 | } | 681 | } //^ S |
697 | 682 | ||
698 | //- /lib.rs crate:core | 683 | //- /lib.rs crate:core |
699 | #[prelude_import] | 684 | #[prelude_import] |
@@ -705,12 +690,11 @@ mod clone { | |||
705 | } | 690 | } |
706 | "#, | 691 | "#, |
707 | ); | 692 | ); |
708 | assert_eq!("S", type_at_pos(&db, pos)); | ||
709 | } | 693 | } |
710 | 694 | ||
711 | #[test] | 695 | #[test] |
712 | fn infer_derive_clone_in_core() { | 696 | fn infer_derive_clone_in_core() { |
713 | let (db, pos) = TestDB::with_position( | 697 | check_types( |
714 | r#" | 698 | r#" |
715 | //- /lib.rs crate:core | 699 | //- /lib.rs crate:core |
716 | #[prelude_import] | 700 | #[prelude_import] |
@@ -726,16 +710,15 @@ pub struct S; | |||
726 | //- /main.rs crate:main deps:core | 710 | //- /main.rs crate:main deps:core |
727 | use core::S; | 711 | use core::S; |
728 | fn test() { | 712 | fn test() { |
729 | S.clone()<|>; | 713 | S.clone(); |
730 | } | 714 | } //^ S |
731 | "#, | 715 | "#, |
732 | ); | 716 | ); |
733 | assert_eq!("S", type_at_pos(&db, pos)); | ||
734 | } | 717 | } |
735 | 718 | ||
736 | #[test] | 719 | #[test] |
737 | fn infer_derive_clone_with_params() { | 720 | fn infer_derive_clone_with_params() { |
738 | let (db, pos) = TestDB::with_position( | 721 | check_types( |
739 | r#" | 722 | r#" |
740 | //- /main.rs crate:main deps:core | 723 | //- /main.rs crate:main deps:core |
741 | #[derive(Clone)] | 724 | #[derive(Clone)] |
@@ -744,7 +727,8 @@ struct S; | |||
744 | struct Wrapper<T>(T); | 727 | struct Wrapper<T>(T); |
745 | struct NonClone; | 728 | struct NonClone; |
746 | fn test() { | 729 | fn test() { |
747 | (Wrapper(S).clone(), Wrapper(NonClone).clone())<|>; | 730 | (Wrapper(S).clone(), Wrapper(NonClone).clone()); |
731 | //^ (Wrapper<S>, {unknown}) | ||
748 | } | 732 | } |
749 | 733 | ||
750 | //- /lib.rs crate:core | 734 | //- /lib.rs crate:core |
@@ -757,13 +741,12 @@ mod clone { | |||
757 | } | 741 | } |
758 | "#, | 742 | "#, |
759 | ); | 743 | ); |
760 | assert_eq!("(Wrapper<S>, {unknown})", type_at_pos(&db, pos)); | ||
761 | } | 744 | } |
762 | 745 | ||
763 | #[test] | 746 | #[test] |
764 | fn infer_custom_derive_simple() { | 747 | fn infer_custom_derive_simple() { |
765 | // FIXME: this test current now do nothing | 748 | // FIXME: this test current now do nothing |
766 | let (db, pos) = TestDB::with_position( | 749 | check_types( |
767 | r#" | 750 | r#" |
768 | //- /main.rs crate:main | 751 | //- /main.rs crate:main |
769 | use foo::Foo; | 752 | use foo::Foo; |
@@ -772,11 +755,10 @@ use foo::Foo; | |||
772 | struct S{} | 755 | struct S{} |
773 | 756 | ||
774 | fn test() { | 757 | fn test() { |
775 | S{}<|>; | 758 | S{}; |
776 | } | 759 | } //^ S |
777 | "#, | 760 | "#, |
778 | ); | 761 | ); |
779 | assert_eq!("S", type_at_pos(&db, pos)); | ||
780 | } | 762 | } |
781 | 763 | ||
782 | #[test] | 764 | #[test] |
diff --git a/crates/ra_hir_ty/src/tests/method_resolution.rs b/crates/ra_hir_ty/src/tests/method_resolution.rs index 20329bae4..9c8f22314 100644 --- a/crates/ra_hir_ty/src/tests/method_resolution.rs +++ b/crates/ra_hir_ty/src/tests/method_resolution.rs | |||
@@ -1,7 +1,6 @@ | |||
1 | use super::{infer, type_at, type_at_pos}; | ||
2 | use crate::test_db::TestDB; | ||
3 | use insta::assert_snapshot; | 1 | use insta::assert_snapshot; |
4 | use ra_db::fixture::WithFixture; | 2 | |
3 | use super::{check_types, infer}; | ||
5 | 4 | ||
6 | #[test] | 5 | #[test] |
7 | fn infer_slice_method() { | 6 | fn infer_slice_method() { |
@@ -246,13 +245,13 @@ fn test() { | |||
246 | 245 | ||
247 | #[test] | 246 | #[test] |
248 | fn cross_crate_associated_method_call() { | 247 | fn cross_crate_associated_method_call() { |
249 | let (db, pos) = TestDB::with_position( | 248 | check_types( |
250 | r#" | 249 | r#" |
251 | //- /main.rs crate:main deps:other_crate | 250 | //- /main.rs crate:main deps:other_crate |
252 | fn test() { | 251 | fn test() { |
253 | let x = other_crate::foo::S::thing(); | 252 | let x = other_crate::foo::S::thing(); |
254 | x<|>; | 253 | x; |
255 | } | 254 | } //^ i128 |
256 | 255 | ||
257 | //- /lib.rs crate:other_crate | 256 | //- /lib.rs crate:other_crate |
258 | mod foo { | 257 | mod foo { |
@@ -263,7 +262,6 @@ mod foo { | |||
263 | } | 262 | } |
264 | "#, | 263 | "#, |
265 | ); | 264 | ); |
266 | assert_eq!("i128", type_at_pos(&db, pos)); | ||
267 | } | 265 | } |
268 | 266 | ||
269 | #[test] | 267 | #[test] |
@@ -684,135 +682,127 @@ fn test() { | |||
684 | 682 | ||
685 | #[test] | 683 | #[test] |
686 | fn method_resolution_unify_impl_self_type() { | 684 | fn method_resolution_unify_impl_self_type() { |
687 | let t = type_at( | 685 | check_types( |
688 | r#" | 686 | r#" |
689 | //- /main.rs | ||
690 | struct S<T>; | 687 | struct S<T>; |
691 | impl S<u32> { fn foo(&self) -> u8 {} } | 688 | impl S<u32> { fn foo(&self) -> u8 {} } |
692 | impl S<i32> { fn foo(&self) -> i8 {} } | 689 | impl S<i32> { fn foo(&self) -> i8 {} } |
693 | fn test() { (S::<u32>.foo(), S::<i32>.foo())<|>; } | 690 | fn test() { (S::<u32>.foo(), S::<i32>.foo()); } |
691 | //^ (u8, i8) | ||
694 | "#, | 692 | "#, |
695 | ); | 693 | ); |
696 | assert_eq!(t, "(u8, i8)"); | ||
697 | } | 694 | } |
698 | 695 | ||
699 | #[test] | 696 | #[test] |
700 | fn method_resolution_trait_before_autoref() { | 697 | fn method_resolution_trait_before_autoref() { |
701 | let t = type_at( | 698 | check_types( |
702 | r#" | 699 | r#" |
703 | //- /main.rs | ||
704 | trait Trait { fn foo(self) -> u128; } | 700 | trait Trait { fn foo(self) -> u128; } |
705 | struct S; | 701 | struct S; |
706 | impl S { fn foo(&self) -> i8 { 0 } } | 702 | impl S { fn foo(&self) -> i8 { 0 } } |
707 | impl Trait for S { fn foo(self) -> u128 { 0 } } | 703 | impl Trait for S { fn foo(self) -> u128 { 0 } } |
708 | fn test() { S.foo()<|>; } | 704 | fn test() { S.foo(); } |
705 | //^ u128 | ||
709 | "#, | 706 | "#, |
710 | ); | 707 | ); |
711 | assert_eq!(t, "u128"); | ||
712 | } | 708 | } |
713 | 709 | ||
714 | #[test] | 710 | #[test] |
715 | fn method_resolution_by_value_before_autoref() { | 711 | fn method_resolution_by_value_before_autoref() { |
716 | let t = type_at( | 712 | check_types( |
717 | r#" | 713 | r#" |
718 | //- /main.rs | ||
719 | trait Clone { fn clone(&self) -> Self; } | 714 | trait Clone { fn clone(&self) -> Self; } |
720 | struct S; | 715 | struct S; |
721 | impl Clone for S {} | 716 | impl Clone for S {} |
722 | impl Clone for &S {} | 717 | impl Clone for &S {} |
723 | fn test() { (S.clone(), (&S).clone(), (&&S).clone())<|>; } | 718 | fn test() { (S.clone(), (&S).clone(), (&&S).clone()); } |
719 | //^ (S, S, &S) | ||
724 | "#, | 720 | "#, |
725 | ); | 721 | ); |
726 | assert_eq!(t, "(S, S, &S)"); | ||
727 | } | 722 | } |
728 | 723 | ||
729 | #[test] | 724 | #[test] |
730 | fn method_resolution_trait_before_autoderef() { | 725 | fn method_resolution_trait_before_autoderef() { |
731 | let t = type_at( | 726 | check_types( |
732 | r#" | 727 | r#" |
733 | //- /main.rs | ||
734 | trait Trait { fn foo(self) -> u128; } | 728 | trait Trait { fn foo(self) -> u128; } |
735 | struct S; | 729 | struct S; |
736 | impl S { fn foo(self) -> i8 { 0 } } | 730 | impl S { fn foo(self) -> i8 { 0 } } |
737 | impl Trait for &S { fn foo(self) -> u128 { 0 } } | 731 | impl Trait for &S { fn foo(self) -> u128 { 0 } } |
738 | fn test() { (&S).foo()<|>; } | 732 | fn test() { (&S).foo(); } |
733 | //^ u128 | ||
739 | "#, | 734 | "#, |
740 | ); | 735 | ); |
741 | assert_eq!(t, "u128"); | ||
742 | } | 736 | } |
743 | 737 | ||
744 | #[test] | 738 | #[test] |
745 | fn method_resolution_impl_before_trait() { | 739 | fn method_resolution_impl_before_trait() { |
746 | let t = type_at( | 740 | check_types( |
747 | r#" | 741 | r#" |
748 | //- /main.rs | ||
749 | trait Trait { fn foo(self) -> u128; } | 742 | trait Trait { fn foo(self) -> u128; } |
750 | struct S; | 743 | struct S; |
751 | impl S { fn foo(self) -> i8 { 0 } } | 744 | impl S { fn foo(self) -> i8 { 0 } } |
752 | impl Trait for S { fn foo(self) -> u128 { 0 } } | 745 | impl Trait for S { fn foo(self) -> u128 { 0 } } |
753 | fn test() { S.foo()<|>; } | 746 | fn test() { S.foo(); } |
747 | //^ i8 | ||
754 | "#, | 748 | "#, |
755 | ); | 749 | ); |
756 | assert_eq!(t, "i8"); | ||
757 | } | 750 | } |
758 | 751 | ||
759 | #[test] | 752 | #[test] |
760 | fn method_resolution_impl_ref_before_trait() { | 753 | fn method_resolution_impl_ref_before_trait() { |
761 | let t = type_at( | 754 | check_types( |
762 | r#" | 755 | r#" |
763 | //- /main.rs | ||
764 | trait Trait { fn foo(self) -> u128; } | 756 | trait Trait { fn foo(self) -> u128; } |
765 | struct S; | 757 | struct S; |
766 | impl S { fn foo(&self) -> i8 { 0 } } | 758 | impl S { fn foo(&self) -> i8 { 0 } } |
767 | impl Trait for &S { fn foo(self) -> u128 { 0 } } | 759 | impl Trait for &S { fn foo(self) -> u128 { 0 } } |
768 | fn test() { S.foo()<|>; } | 760 | fn test() { S.foo(); } |
761 | //^ i8 | ||
769 | "#, | 762 | "#, |
770 | ); | 763 | ); |
771 | assert_eq!(t, "i8"); | ||
772 | } | 764 | } |
773 | 765 | ||
774 | #[test] | 766 | #[test] |
775 | fn method_resolution_trait_autoderef() { | 767 | fn method_resolution_trait_autoderef() { |
776 | let t = type_at( | 768 | check_types( |
777 | r#" | 769 | r#" |
778 | //- /main.rs | ||
779 | trait Trait { fn foo(self) -> u128; } | 770 | trait Trait { fn foo(self) -> u128; } |
780 | struct S; | 771 | struct S; |
781 | impl Trait for S { fn foo(self) -> u128 { 0 } } | 772 | impl Trait for S { fn foo(self) -> u128 { 0 } } |
782 | fn test() { (&S).foo()<|>; } | 773 | fn test() { (&S).foo(); } |
774 | //^ u128 | ||
783 | "#, | 775 | "#, |
784 | ); | 776 | ); |
785 | assert_eq!(t, "u128"); | ||
786 | } | 777 | } |
787 | 778 | ||
788 | #[test] | 779 | #[test] |
789 | fn method_resolution_unsize_array() { | 780 | fn method_resolution_unsize_array() { |
790 | let t = type_at( | 781 | check_types( |
791 | r#" | 782 | r#" |
792 | //- /main.rs | ||
793 | #[lang = "slice"] | 783 | #[lang = "slice"] |
794 | impl<T> [T] { | 784 | impl<T> [T] { |
795 | fn len(&self) -> usize { loop {} } | 785 | fn len(&self) -> usize { loop {} } |
796 | } | 786 | } |
797 | fn test() { | 787 | fn test() { |
798 | let a = [1, 2, 3]; | 788 | let a = [1, 2, 3]; |
799 | a.len()<|>; | 789 | a.len(); |
800 | } | 790 | } //^ usize |
801 | "#, | 791 | "#, |
802 | ); | 792 | ); |
803 | assert_eq!(t, "usize"); | ||
804 | } | 793 | } |
805 | 794 | ||
806 | #[test] | 795 | #[test] |
807 | fn method_resolution_trait_from_prelude() { | 796 | fn method_resolution_trait_from_prelude() { |
808 | let (db, pos) = TestDB::with_position( | 797 | check_types( |
809 | r#" | 798 | r#" |
810 | //- /main.rs crate:main deps:other_crate | 799 | //- /main.rs crate:main deps:other_crate |
811 | struct S; | 800 | struct S; |
812 | impl Clone for S {} | 801 | impl Clone for S {} |
813 | 802 | ||
814 | fn test() { | 803 | fn test() { |
815 | S.clone()<|>; | 804 | S.clone(); |
805 | //^ S | ||
816 | } | 806 | } |
817 | 807 | ||
818 | //- /lib.rs crate:other_crate | 808 | //- /lib.rs crate:other_crate |
@@ -825,115 +815,107 @@ mod foo { | |||
825 | } | 815 | } |
826 | "#, | 816 | "#, |
827 | ); | 817 | ); |
828 | assert_eq!("S", type_at_pos(&db, pos)); | ||
829 | } | 818 | } |
830 | 819 | ||
831 | #[test] | 820 | #[test] |
832 | fn method_resolution_where_clause_for_unknown_trait() { | 821 | fn method_resolution_where_clause_for_unknown_trait() { |
833 | // The blanket impl currently applies because we ignore the unresolved where clause | 822 | // The blanket impl currently applies because we ignore the unresolved where clause |
834 | let t = type_at( | 823 | check_types( |
835 | r#" | 824 | r#" |
836 | //- /main.rs | ||
837 | trait Trait { fn foo(self) -> u128; } | 825 | trait Trait { fn foo(self) -> u128; } |
838 | struct S; | 826 | struct S; |
839 | impl<T> Trait for T where T: UnknownTrait {} | 827 | impl<T> Trait for T where T: UnknownTrait {} |
840 | fn test() { (&S).foo()<|>; } | 828 | fn test() { (&S).foo(); } |
829 | //^ u128 | ||
841 | "#, | 830 | "#, |
842 | ); | 831 | ); |
843 | assert_eq!(t, "u128"); | ||
844 | } | 832 | } |
845 | 833 | ||
846 | #[test] | 834 | #[test] |
847 | fn method_resolution_where_clause_not_met() { | 835 | fn method_resolution_where_clause_not_met() { |
848 | // The blanket impl shouldn't apply because we can't prove S: Clone | 836 | // The blanket impl shouldn't apply because we can't prove S: Clone |
849 | let t = type_at( | 837 | // This is also to make sure that we don't resolve to the foo method just |
838 | // because that's the only method named foo we can find, which would make | ||
839 | // the below tests not work | ||
840 | check_types( | ||
850 | r#" | 841 | r#" |
851 | //- /main.rs | ||
852 | trait Clone {} | 842 | trait Clone {} |
853 | trait Trait { fn foo(self) -> u128; } | 843 | trait Trait { fn foo(self) -> u128; } |
854 | struct S; | 844 | struct S; |
855 | impl<T> Trait for T where T: Clone {} | 845 | impl<T> Trait for T where T: Clone {} |
856 | fn test() { (&S).foo()<|>; } | 846 | fn test() { (&S).foo(); } |
847 | //^ {unknown} | ||
857 | "#, | 848 | "#, |
858 | ); | 849 | ); |
859 | // This is also to make sure that we don't resolve to the foo method just | ||
860 | // because that's the only method named foo we can find, which would make | ||
861 | // the below tests not work | ||
862 | assert_eq!(t, "{unknown}"); | ||
863 | } | 850 | } |
864 | 851 | ||
865 | #[test] | 852 | #[test] |
866 | fn method_resolution_where_clause_inline_not_met() { | 853 | fn method_resolution_where_clause_inline_not_met() { |
867 | // The blanket impl shouldn't apply because we can't prove S: Clone | 854 | // The blanket impl shouldn't apply because we can't prove S: Clone |
868 | let t = type_at( | 855 | check_types( |
869 | r#" | 856 | r#" |
870 | //- /main.rs | ||
871 | trait Clone {} | 857 | trait Clone {} |
872 | trait Trait { fn foo(self) -> u128; } | 858 | trait Trait { fn foo(self) -> u128; } |
873 | struct S; | 859 | struct S; |
874 | impl<T: Clone> Trait for T {} | 860 | impl<T: Clone> Trait for T {} |
875 | fn test() { (&S).foo()<|>; } | 861 | fn test() { (&S).foo(); } |
862 | //^ {unknown} | ||
876 | "#, | 863 | "#, |
877 | ); | 864 | ); |
878 | assert_eq!(t, "{unknown}"); | ||
879 | } | 865 | } |
880 | 866 | ||
881 | #[test] | 867 | #[test] |
882 | fn method_resolution_where_clause_1() { | 868 | fn method_resolution_where_clause_1() { |
883 | let t = type_at( | 869 | check_types( |
884 | r#" | 870 | r#" |
885 | //- /main.rs | ||
886 | trait Clone {} | 871 | trait Clone {} |
887 | trait Trait { fn foo(self) -> u128; } | 872 | trait Trait { fn foo(self) -> u128; } |
888 | struct S; | 873 | struct S; |
889 | impl Clone for S {} | 874 | impl Clone for S {} |
890 | impl<T> Trait for T where T: Clone {} | 875 | impl<T> Trait for T where T: Clone {} |
891 | fn test() { S.foo()<|>; } | 876 | fn test() { S.foo(); } |
877 | //^ u128 | ||
892 | "#, | 878 | "#, |
893 | ); | 879 | ); |
894 | assert_eq!(t, "u128"); | ||
895 | } | 880 | } |
896 | 881 | ||
897 | #[test] | 882 | #[test] |
898 | fn method_resolution_where_clause_2() { | 883 | fn method_resolution_where_clause_2() { |
899 | let t = type_at( | 884 | check_types( |
900 | r#" | 885 | r#" |
901 | //- /main.rs | ||
902 | trait Into<T> { fn into(self) -> T; } | 886 | trait Into<T> { fn into(self) -> T; } |
903 | trait From<T> { fn from(other: T) -> Self; } | 887 | trait From<T> { fn from(other: T) -> Self; } |
904 | struct S1; | 888 | struct S1; |
905 | struct S2; | 889 | struct S2; |
906 | impl From<S2> for S1 {} | 890 | impl From<S2> for S1 {} |
907 | impl<T, U> Into<U> for T where U: From<T> {} | 891 | impl<T, U> Into<U> for T where U: From<T> {} |
908 | fn test() { S2.into()<|>; } | 892 | fn test() { S2.into(); } |
893 | //^ {unknown} | ||
909 | "#, | 894 | "#, |
910 | ); | 895 | ); |
911 | assert_eq!(t, "{unknown}"); | ||
912 | } | 896 | } |
913 | 897 | ||
914 | #[test] | 898 | #[test] |
915 | fn method_resolution_where_clause_inline() { | 899 | fn method_resolution_where_clause_inline() { |
916 | let t = type_at( | 900 | check_types( |
917 | r#" | 901 | r#" |
918 | //- /main.rs | ||
919 | trait Into<T> { fn into(self) -> T; } | 902 | trait Into<T> { fn into(self) -> T; } |
920 | trait From<T> { fn from(other: T) -> Self; } | 903 | trait From<T> { fn from(other: T) -> Self; } |
921 | struct S1; | 904 | struct S1; |
922 | struct S2; | 905 | struct S2; |
923 | impl From<S2> for S1 {} | 906 | impl From<S2> for S1 {} |
924 | impl<T, U: From<T>> Into<U> for T {} | 907 | impl<T, U: From<T>> Into<U> for T {} |
925 | fn test() { S2.into()<|>; } | 908 | fn test() { S2.into(); } |
909 | //^ {unknown} | ||
926 | "#, | 910 | "#, |
927 | ); | 911 | ); |
928 | assert_eq!(t, "{unknown}"); | ||
929 | } | 912 | } |
930 | 913 | ||
931 | #[test] | 914 | #[test] |
932 | fn method_resolution_overloaded_method() { | 915 | fn method_resolution_overloaded_method() { |
933 | test_utils::mark::check!(impl_self_type_match_without_receiver); | 916 | test_utils::mark::check!(impl_self_type_match_without_receiver); |
934 | let t = type_at( | 917 | check_types( |
935 | r#" | 918 | r#" |
936 | //- /main.rs | ||
937 | struct Wrapper<T>(T); | 919 | struct Wrapper<T>(T); |
938 | struct Foo<T>(T); | 920 | struct Foo<T>(T); |
939 | struct Bar<T>(T); | 921 | struct Bar<T>(T); |
@@ -953,30 +935,30 @@ impl<T> Wrapper<Bar<T>> { | |||
953 | fn main() { | 935 | fn main() { |
954 | let a = Wrapper::<Foo<f32>>::new(1.0); | 936 | let a = Wrapper::<Foo<f32>>::new(1.0); |
955 | let b = Wrapper::<Bar<f32>>::new(1.0); | 937 | let b = Wrapper::<Bar<f32>>::new(1.0); |
956 | (a, b)<|>; | 938 | (a, b); |
939 | //^ (Wrapper<Foo<f32>>, Wrapper<Bar<f32>>) | ||
957 | } | 940 | } |
958 | "#, | 941 | "#, |
959 | ); | 942 | ); |
960 | assert_eq!(t, "(Wrapper<Foo<f32>>, Wrapper<Bar<f32>>)") | ||
961 | } | 943 | } |
962 | 944 | ||
963 | #[test] | 945 | #[test] |
964 | fn method_resolution_encountering_fn_type() { | 946 | fn method_resolution_encountering_fn_type() { |
965 | type_at( | 947 | check_types( |
966 | r#" | 948 | r#" |
967 | //- /main.rs | 949 | //- /main.rs |
968 | fn foo() {} | 950 | fn foo() {} |
969 | trait FnOnce { fn call(self); } | 951 | trait FnOnce { fn call(self); } |
970 | fn test() { foo.call()<|>; } | 952 | fn test() { foo.call(); } |
953 | //^ {unknown} | ||
971 | "#, | 954 | "#, |
972 | ); | 955 | ); |
973 | } | 956 | } |
974 | 957 | ||
975 | #[test] | 958 | #[test] |
976 | fn method_resolution_non_parameter_type() { | 959 | fn method_resolution_non_parameter_type() { |
977 | let t = type_at( | 960 | check_types( |
978 | r#" | 961 | r#" |
979 | //- /main.rs | ||
980 | mod a { | 962 | mod a { |
981 | pub trait Foo { | 963 | pub trait Foo { |
982 | fn foo(&self); | 964 | fn foo(&self); |
@@ -988,18 +970,16 @@ fn foo<T>(t: Wrapper<T>) | |||
988 | where | 970 | where |
989 | Wrapper<T>: a::Foo, | 971 | Wrapper<T>: a::Foo, |
990 | { | 972 | { |
991 | t.foo()<|>; | 973 | t.foo(); |
992 | } | 974 | } //^ {unknown} |
993 | "#, | 975 | "#, |
994 | ); | 976 | ); |
995 | assert_eq!(t, "{unknown}"); | ||
996 | } | 977 | } |
997 | 978 | ||
998 | #[test] | 979 | #[test] |
999 | fn method_resolution_3373() { | 980 | fn method_resolution_3373() { |
1000 | let t = type_at( | 981 | check_types( |
1001 | r#" | 982 | r#" |
1002 | //- /main.rs | ||
1003 | struct A<T>(T); | 983 | struct A<T>(T); |
1004 | 984 | ||
1005 | impl A<i32> { | 985 | impl A<i32> { |
@@ -1007,19 +987,17 @@ impl A<i32> { | |||
1007 | } | 987 | } |
1008 | 988 | ||
1009 | fn main() { | 989 | fn main() { |
1010 | A::from(3)<|>; | 990 | A::from(3); |
1011 | } | 991 | } //^ A<i32> |
1012 | "#, | 992 | "#, |
1013 | ); | 993 | ); |
1014 | assert_eq!(t, "A<i32>"); | ||
1015 | } | 994 | } |
1016 | 995 | ||
1017 | #[test] | 996 | #[test] |
1018 | fn method_resolution_slow() { | 997 | fn method_resolution_slow() { |
1019 | // this can get quite slow if we set the solver size limit too high | 998 | // this can get quite slow if we set the solver size limit too high |
1020 | let t = type_at( | 999 | check_types( |
1021 | r#" | 1000 | r#" |
1022 | //- /main.rs | ||
1023 | trait SendX {} | 1001 | trait SendX {} |
1024 | 1002 | ||
1025 | struct S1; impl SendX for S1 {} | 1003 | struct S1; impl SendX for S1 {} |
@@ -1037,10 +1015,10 @@ trait FnX {} | |||
1037 | 1015 | ||
1038 | impl<B, C> Trait for S<B, C> where C: FnX, B: SendX {} | 1016 | impl<B, C> Trait for S<B, C> where C: FnX, B: SendX {} |
1039 | 1017 | ||
1040 | fn test() { (S {}).method()<|>; } | 1018 | fn test() { (S {}).method(); } |
1019 | //^ () | ||
1041 | "#, | 1020 | "#, |
1042 | ); | 1021 | ); |
1043 | assert_eq!(t, "()"); | ||
1044 | } | 1022 | } |
1045 | 1023 | ||
1046 | #[test] | 1024 | #[test] |
diff --git a/crates/ra_hir_ty/src/tests/never_type.rs b/crates/ra_hir_ty/src/tests/never_type.rs index ab9a990f5..64d421d40 100644 --- a/crates/ra_hir_ty/src/tests/never_type.rs +++ b/crates/ra_hir_ty/src/tests/never_type.rs | |||
@@ -1,99 +1,91 @@ | |||
1 | use insta::assert_snapshot; | 1 | use insta::assert_snapshot; |
2 | 2 | ||
3 | use super::{infer_with_mismatches, type_at}; | 3 | use super::{check_types, infer_with_mismatches}; |
4 | 4 | ||
5 | #[test] | 5 | #[test] |
6 | fn infer_never1() { | 6 | fn infer_never1() { |
7 | let t = type_at( | 7 | check_types( |
8 | r#" | 8 | r#" |
9 | //- /main.rs | ||
10 | fn test() { | 9 | fn test() { |
11 | let t = return; | 10 | let t = return; |
12 | t<|>; | 11 | t; |
13 | } | 12 | } //^ ! |
14 | "#, | 13 | "#, |
15 | ); | 14 | ); |
16 | assert_eq!(t, "!"); | ||
17 | } | 15 | } |
18 | 16 | ||
19 | #[test] | 17 | #[test] |
20 | fn infer_never2() { | 18 | fn infer_never2() { |
21 | let t = type_at( | 19 | check_types( |
22 | r#" | 20 | r#" |
23 | //- /main.rs | ||
24 | fn gen<T>() -> T { loop {} } | 21 | fn gen<T>() -> T { loop {} } |
25 | 22 | ||
26 | fn test() { | 23 | fn test() { |
27 | let a = gen(); | 24 | let a = gen(); |
28 | if false { a } else { loop {} }; | 25 | if false { a } else { loop {} }; |
29 | a<|>; | 26 | a; |
30 | } | 27 | } //^ ! |
31 | "#, | 28 | "#, |
32 | ); | 29 | ); |
33 | assert_eq!(t, "!"); | ||
34 | } | 30 | } |
35 | 31 | ||
36 | #[test] | 32 | #[test] |
37 | fn infer_never3() { | 33 | fn infer_never3() { |
38 | let t = type_at( | 34 | check_types( |
39 | r#" | 35 | r#" |
40 | //- /main.rs | ||
41 | fn gen<T>() -> T { loop {} } | 36 | fn gen<T>() -> T { loop {} } |
42 | 37 | ||
43 | fn test() { | 38 | fn test() { |
44 | let a = gen(); | 39 | let a = gen(); |
45 | if false { loop {} } else { a }; | 40 | if false { loop {} } else { a }; |
46 | a<|>; | 41 | a; |
42 | //^ ! | ||
47 | } | 43 | } |
48 | "#, | 44 | "#, |
49 | ); | 45 | ); |
50 | assert_eq!(t, "!"); | ||
51 | } | 46 | } |
52 | 47 | ||
53 | #[test] | 48 | #[test] |
54 | fn never_type_in_generic_args() { | 49 | fn never_type_in_generic_args() { |
55 | let t = type_at( | 50 | check_types( |
56 | r#" | 51 | r#" |
57 | //- /main.rs | ||
58 | enum Option<T> { None, Some(T) } | 52 | enum Option<T> { None, Some(T) } |
59 | 53 | ||
60 | fn test() { | 54 | fn test() { |
61 | let a = if true { Option::None } else { Option::Some(return) }; | 55 | let a = if true { Option::None } else { Option::Some(return) }; |
62 | a<|>; | 56 | a; |
63 | } | 57 | } //^ Option<!> |
64 | "#, | 58 | "#, |
65 | ); | 59 | ); |
66 | assert_eq!(t, "Option<!>"); | ||
67 | } | 60 | } |
68 | 61 | ||
69 | #[test] | 62 | #[test] |
70 | fn never_type_can_be_reinferred1() { | 63 | fn never_type_can_be_reinferred1() { |
71 | let t = type_at( | 64 | check_types( |
72 | r#" | 65 | r#" |
73 | //- /main.rs | ||
74 | fn gen<T>() -> T { loop {} } | 66 | fn gen<T>() -> T { loop {} } |
75 | 67 | ||
76 | fn test() { | 68 | fn test() { |
77 | let a = gen(); | 69 | let a = gen(); |
78 | if false { loop {} } else { a }; | 70 | if false { loop {} } else { a }; |
79 | a<|>; | 71 | a; |
72 | //^ () | ||
80 | if false { a }; | 73 | if false { a }; |
81 | } | 74 | } |
82 | "#, | 75 | "#, |
83 | ); | 76 | ); |
84 | assert_eq!(t, "()"); | ||
85 | } | 77 | } |
86 | 78 | ||
87 | #[test] | 79 | #[test] |
88 | fn never_type_can_be_reinferred2() { | 80 | fn never_type_can_be_reinferred2() { |
89 | let t = type_at( | 81 | check_types( |
90 | r#" | 82 | r#" |
91 | //- /main.rs | ||
92 | enum Option<T> { None, Some(T) } | 83 | enum Option<T> { None, Some(T) } |
93 | 84 | ||
94 | fn test() { | 85 | fn test() { |
95 | let a = if true { Option::None } else { Option::Some(return) }; | 86 | let a = if true { Option::None } else { Option::Some(return) }; |
96 | a<|>; | 87 | a; |
88 | //^ Option<i32> | ||
97 | match 42 { | 89 | match 42 { |
98 | 42 => a, | 90 | 42 => a, |
99 | _ => Option::Some(42), | 91 | _ => Option::Some(42), |
@@ -101,19 +93,18 @@ fn test() { | |||
101 | } | 93 | } |
102 | "#, | 94 | "#, |
103 | ); | 95 | ); |
104 | assert_eq!(t, "Option<i32>"); | ||
105 | } | 96 | } |
106 | 97 | ||
107 | #[test] | 98 | #[test] |
108 | fn never_type_can_be_reinferred3() { | 99 | fn never_type_can_be_reinferred3() { |
109 | let t = type_at( | 100 | check_types( |
110 | r#" | 101 | r#" |
111 | //- /main.rs | ||
112 | enum Option<T> { None, Some(T) } | 102 | enum Option<T> { None, Some(T) } |
113 | 103 | ||
114 | fn test() { | 104 | fn test() { |
115 | let a = if true { Option::None } else { Option::Some(return) }; | 105 | let a = if true { Option::None } else { Option::Some(return) }; |
116 | a<|>; | 106 | a; |
107 | //^ Option<&str> | ||
117 | match 42 { | 108 | match 42 { |
118 | 42 => a, | 109 | 42 => a, |
119 | _ => Option::Some("str"), | 110 | _ => Option::Some("str"), |
@@ -121,82 +112,72 @@ fn test() { | |||
121 | } | 112 | } |
122 | "#, | 113 | "#, |
123 | ); | 114 | ); |
124 | assert_eq!(t, "Option<&str>"); | ||
125 | } | 115 | } |
126 | 116 | ||
127 | #[test] | 117 | #[test] |
128 | fn match_no_arm() { | 118 | fn match_no_arm() { |
129 | let t = type_at( | 119 | check_types( |
130 | r#" | 120 | r#" |
131 | //- /main.rs | ||
132 | enum Void {} | 121 | enum Void {} |
133 | 122 | ||
134 | fn test(a: Void) { | 123 | fn test(a: Void) { |
135 | let t = match a {}; | 124 | let t = match a {}; |
136 | t<|>; | 125 | t; |
137 | } | 126 | } //^ ! |
138 | "#, | 127 | "#, |
139 | ); | 128 | ); |
140 | assert_eq!(t, "!"); | ||
141 | } | 129 | } |
142 | 130 | ||
143 | #[test] | 131 | #[test] |
144 | fn match_unknown_arm() { | 132 | fn match_unknown_arm() { |
145 | let t = type_at( | 133 | check_types( |
146 | r#" | 134 | r#" |
147 | //- /main.rs | ||
148 | fn test(a: Option) { | 135 | fn test(a: Option) { |
149 | let t = match 0 { | 136 | let t = match 0 { |
150 | _ => unknown, | 137 | _ => unknown, |
151 | }; | 138 | }; |
152 | t<|>; | 139 | t; |
153 | } | 140 | } //^ {unknown} |
154 | "#, | 141 | "#, |
155 | ); | 142 | ); |
156 | assert_eq!(t, "{unknown}"); | ||
157 | } | 143 | } |
158 | 144 | ||
159 | #[test] | 145 | #[test] |
160 | fn if_never() { | 146 | fn if_never() { |
161 | let t = type_at( | 147 | check_types( |
162 | r#" | 148 | r#" |
163 | //- /main.rs | ||
164 | fn test() { | 149 | fn test() { |
165 | let i = if true { | 150 | let i = if true { |
166 | loop {} | 151 | loop {} |
167 | } else { | 152 | } else { |
168 | 3.0 | 153 | 3.0 |
169 | }; | 154 | }; |
170 | i<|>; | 155 | i; |
171 | } | 156 | } //^ f64 |
172 | "#, | 157 | "#, |
173 | ); | 158 | ); |
174 | assert_eq!(t, "f64"); | ||
175 | } | 159 | } |
176 | 160 | ||
177 | #[test] | 161 | #[test] |
178 | fn if_else_never() { | 162 | fn if_else_never() { |
179 | let t = type_at( | 163 | check_types( |
180 | r#" | 164 | r#" |
181 | //- /main.rs | ||
182 | fn test(input: bool) { | 165 | fn test(input: bool) { |
183 | let i = if input { | 166 | let i = if input { |
184 | 2.0 | 167 | 2.0 |
185 | } else { | 168 | } else { |
186 | return | 169 | return |
187 | }; | 170 | }; |
188 | i<|>; | 171 | i; |
189 | } | 172 | } //^ f64 |
190 | "#, | 173 | "#, |
191 | ); | 174 | ); |
192 | assert_eq!(t, "f64"); | ||
193 | } | 175 | } |
194 | 176 | ||
195 | #[test] | 177 | #[test] |
196 | fn match_first_arm_never() { | 178 | fn match_first_arm_never() { |
197 | let t = type_at( | 179 | check_types( |
198 | r#" | 180 | r#" |
199 | //- /main.rs | ||
200 | fn test(a: i32) { | 181 | fn test(a: i32) { |
201 | let i = match a { | 182 | let i = match a { |
202 | 1 => return, | 183 | 1 => return, |
@@ -204,18 +185,16 @@ fn test(a: i32) { | |||
204 | 3 => loop {}, | 185 | 3 => loop {}, |
205 | _ => 3.0, | 186 | _ => 3.0, |
206 | }; | 187 | }; |
207 | i<|>; | 188 | i; |
208 | } | 189 | } //^ f64 |
209 | "#, | 190 | "#, |
210 | ); | 191 | ); |
211 | assert_eq!(t, "f64"); | ||
212 | } | 192 | } |
213 | 193 | ||
214 | #[test] | 194 | #[test] |
215 | fn match_second_arm_never() { | 195 | fn match_second_arm_never() { |
216 | let t = type_at( | 196 | check_types( |
217 | r#" | 197 | r#" |
218 | //- /main.rs | ||
219 | fn test(a: i32) { | 198 | fn test(a: i32) { |
220 | let i = match a { | 199 | let i = match a { |
221 | 1 => 3.0, | 200 | 1 => 3.0, |
@@ -223,45 +202,40 @@ fn test(a: i32) { | |||
223 | 3 => 3.0, | 202 | 3 => 3.0, |
224 | _ => return, | 203 | _ => return, |
225 | }; | 204 | }; |
226 | i<|>; | 205 | i; |
227 | } | 206 | } //^ f64 |
228 | "#, | 207 | "#, |
229 | ); | 208 | ); |
230 | assert_eq!(t, "f64"); | ||
231 | } | 209 | } |
232 | 210 | ||
233 | #[test] | 211 | #[test] |
234 | fn match_all_arms_never() { | 212 | fn match_all_arms_never() { |
235 | let t = type_at( | 213 | check_types( |
236 | r#" | 214 | r#" |
237 | //- /main.rs | ||
238 | fn test(a: i32) { | 215 | fn test(a: i32) { |
239 | let i = match a { | 216 | let i = match a { |
240 | 2 => return, | 217 | 2 => return, |
241 | _ => loop {}, | 218 | _ => loop {}, |
242 | }; | 219 | }; |
243 | i<|>; | 220 | i; |
244 | } | 221 | } //^ ! |
245 | "#, | 222 | "#, |
246 | ); | 223 | ); |
247 | assert_eq!(t, "!"); | ||
248 | } | 224 | } |
249 | 225 | ||
250 | #[test] | 226 | #[test] |
251 | fn match_no_never_arms() { | 227 | fn match_no_never_arms() { |
252 | let t = type_at( | 228 | check_types( |
253 | r#" | 229 | r#" |
254 | //- /main.rs | ||
255 | fn test(a: i32) { | 230 | fn test(a: i32) { |
256 | let i = match a { | 231 | let i = match a { |
257 | 2 => 2.0, | 232 | 2 => 2.0, |
258 | _ => 3.0, | 233 | _ => 3.0, |
259 | }; | 234 | }; |
260 | i<|>; | 235 | i; |
261 | } | 236 | } //^ f64 |
262 | "#, | 237 | "#, |
263 | ); | 238 | ); |
264 | assert_eq!(t, "f64"); | ||
265 | } | 239 | } |
266 | 240 | ||
267 | #[test] | 241 | #[test] |
diff --git a/crates/ra_hir_ty/src/tests/regression.rs b/crates/ra_hir_ty/src/tests/regression.rs index aa37326df..d806e0ffb 100644 --- a/crates/ra_hir_ty/src/tests/regression.rs +++ b/crates/ra_hir_ty/src/tests/regression.rs | |||
@@ -1,10 +1,7 @@ | |||
1 | use insta::assert_snapshot; | 1 | use insta::assert_snapshot; |
2 | use ra_db::fixture::WithFixture; | ||
3 | use test_utils::mark; | 2 | use test_utils::mark; |
4 | 3 | ||
5 | use crate::test_db::TestDB; | 4 | use super::{check_types, infer}; |
6 | |||
7 | use super::infer; | ||
8 | 5 | ||
9 | #[test] | 6 | #[test] |
10 | fn bug_484() { | 7 | fn bug_484() { |
@@ -404,13 +401,13 @@ fn test() { | |||
404 | 401 | ||
405 | #[test] | 402 | #[test] |
406 | fn issue_2683_chars_impl() { | 403 | fn issue_2683_chars_impl() { |
407 | let (db, pos) = TestDB::with_position( | 404 | check_types( |
408 | r#" | 405 | r#" |
409 | //- /main.rs crate:main deps:std | 406 | //- /main.rs crate:main deps:std |
410 | fn test() { | 407 | fn test() { |
411 | let chars: std::str::Chars<'_>; | 408 | let chars: std::str::Chars<'_>; |
412 | (chars.next(), chars.nth(1))<|>; | 409 | (chars.next(), chars.nth(1)); |
413 | } | 410 | } //^ (Option<char>, Option<char>) |
414 | 411 | ||
415 | //- /std.rs crate:std | 412 | //- /std.rs crate:std |
416 | #[prelude_import] | 413 | #[prelude_import] |
@@ -449,15 +446,12 @@ pub mod str { | |||
449 | } | 446 | } |
450 | "#, | 447 | "#, |
451 | ); | 448 | ); |
452 | |||
453 | assert_eq!("(Option<char>, Option<char>)", super::type_at_pos(&db, pos)); | ||
454 | } | 449 | } |
455 | 450 | ||
456 | #[test] | 451 | #[test] |
457 | fn issue_3642_bad_macro_stackover() { | 452 | fn issue_3642_bad_macro_stackover() { |
458 | let (db, pos) = TestDB::with_position( | 453 | check_types( |
459 | r#" | 454 | r#" |
460 | //- /main.rs | ||
461 | #[macro_export] | 455 | #[macro_export] |
462 | macro_rules! match_ast { | 456 | macro_rules! match_ast { |
463 | (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) }; | 457 | (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) }; |
@@ -472,7 +466,8 @@ macro_rules! match_ast { | |||
472 | } | 466 | } |
473 | 467 | ||
474 | fn main() { | 468 | fn main() { |
475 | let anchor<|> = match_ast! { | 469 | let anchor = match_ast! { |
470 | //^ () | ||
476 | match parent { | 471 | match parent { |
477 | as => {}, | 472 | as => {}, |
478 | _ => return None | 473 | _ => return None |
@@ -480,8 +475,6 @@ fn main() { | |||
480 | }; | 475 | }; |
481 | }"#, | 476 | }"#, |
482 | ); | 477 | ); |
483 | |||
484 | assert_eq!("()", super::type_at_pos(&db, pos)); | ||
485 | } | 478 | } |
486 | 479 | ||
487 | #[test] | 480 | #[test] |
diff --git a/crates/ra_hir_ty/src/tests/simple.rs b/crates/ra_hir_ty/src/tests/simple.rs index 7d8197f8b..de63f4cce 100644 --- a/crates/ra_hir_ty/src/tests/simple.rs +++ b/crates/ra_hir_ty/src/tests/simple.rs | |||
@@ -1,19 +1,17 @@ | |||
1 | use super::{infer, type_at, type_at_pos}; | ||
2 | use crate::test_db::TestDB; | ||
3 | use insta::assert_snapshot; | 1 | use insta::assert_snapshot; |
4 | use ra_db::fixture::WithFixture; | 2 | |
3 | use super::{check_types, infer}; | ||
5 | 4 | ||
6 | #[test] | 5 | #[test] |
7 | fn infer_box() { | 6 | fn infer_box() { |
8 | let (db, pos) = TestDB::with_position( | 7 | check_types( |
9 | r#" | 8 | r#" |
10 | //- /main.rs crate:main deps:std | 9 | //- /main.rs crate:main deps:std |
11 | |||
12 | fn test() { | 10 | fn test() { |
13 | let x = box 1; | 11 | let x = box 1; |
14 | let t = (x, box x, box &1, box [1]); | 12 | let t = (x, box x, box &1, box [1]); |
15 | t<|>; | 13 | t; |
16 | } | 14 | } //^ (Box<i32>, Box<Box<i32>>, Box<&i32>, Box<[i32; _]>) |
17 | 15 | ||
18 | //- /std.rs crate:std | 16 | //- /std.rs crate:std |
19 | #[prelude_import] use prelude::*; | 17 | #[prelude_import] use prelude::*; |
@@ -25,29 +23,24 @@ mod boxed { | |||
25 | inner: *mut T, | 23 | inner: *mut T, |
26 | } | 24 | } |
27 | } | 25 | } |
28 | |||
29 | "#, | 26 | "#, |
30 | ); | 27 | ); |
31 | assert_eq!("(Box<i32>, Box<Box<i32>>, Box<&i32>, Box<[i32; _]>)", type_at_pos(&db, pos)); | ||
32 | } | 28 | } |
33 | 29 | ||
34 | #[test] | 30 | #[test] |
35 | fn infer_adt_self() { | 31 | fn infer_adt_self() { |
36 | let (db, pos) = TestDB::with_position( | 32 | check_types( |
37 | r#" | 33 | r#" |
38 | //- /main.rs | ||
39 | enum Nat { Succ(Self), Demo(Nat), Zero } | 34 | enum Nat { Succ(Self), Demo(Nat), Zero } |
40 | 35 | ||
41 | fn test() { | 36 | fn test() { |
42 | let foo: Nat = Nat::Zero; | 37 | let foo: Nat = Nat::Zero; |
43 | if let Nat::Succ(x) = foo { | 38 | if let Nat::Succ(x) = foo { |
44 | x<|> | 39 | x |
45 | } | 40 | } //^ Nat |
46 | } | 41 | } |
47 | |||
48 | "#, | 42 | "#, |
49 | ); | 43 | ); |
50 | assert_eq!("Nat", type_at_pos(&db, pos)); | ||
51 | } | 44 | } |
52 | 45 | ||
53 | #[test] | 46 | #[test] |
@@ -93,7 +86,7 @@ fn foo() { | |||
93 | 86 | ||
94 | #[test] | 87 | #[test] |
95 | fn infer_ranges() { | 88 | fn infer_ranges() { |
96 | let (db, pos) = TestDB::with_position( | 89 | check_types( |
97 | r#" | 90 | r#" |
98 | //- /main.rs crate:main deps:core | 91 | //- /main.rs crate:main deps:core |
99 | fn test() { | 92 | fn test() { |
@@ -105,8 +98,8 @@ fn test() { | |||
105 | let f = 'a'..='z'; | 98 | let f = 'a'..='z'; |
106 | 99 | ||
107 | let t = (a, b, c, d, e, f); | 100 | let t = (a, b, c, d, e, f); |
108 | t<|>; | 101 | t; |
109 | } | 102 | } //^ (RangeFull, RangeFrom<i32>, RangeTo<u32>, Range<usize>, RangeToInclusive<i32>, RangeInclusive<char>) |
110 | 103 | ||
111 | //- /core.rs crate:core | 104 | //- /core.rs crate:core |
112 | #[prelude_import] use prelude::*; | 105 | #[prelude_import] use prelude::*; |
@@ -135,29 +128,22 @@ pub mod ops { | |||
135 | } | 128 | } |
136 | "#, | 129 | "#, |
137 | ); | 130 | ); |
138 | assert_eq!( | ||
139 | "(RangeFull, RangeFrom<i32>, RangeTo<u32>, Range<usize>, RangeToInclusive<i32>, RangeInclusive<char>)", | ||
140 | type_at_pos(&db, pos), | ||
141 | ); | ||
142 | } | 131 | } |
143 | 132 | ||
144 | #[test] | 133 | #[test] |
145 | fn infer_while_let() { | 134 | fn infer_while_let() { |
146 | let (db, pos) = TestDB::with_position( | 135 | check_types( |
147 | r#" | 136 | r#" |
148 | //- /main.rs | ||
149 | enum Option<T> { Some(T), None } | 137 | enum Option<T> { Some(T), None } |
150 | 138 | ||
151 | fn test() { | 139 | fn test() { |
152 | let foo: Option<f32> = None; | 140 | let foo: Option<f32> = None; |
153 | while let Option::Some(x) = foo { | 141 | while let Option::Some(x) = foo { |
154 | <|>x | 142 | x |
155 | } | 143 | } //^ f32 |
156 | } | 144 | } |
157 | |||
158 | "#, | 145 | "#, |
159 | ); | 146 | ); |
160 | assert_eq!("f32", type_at_pos(&db, pos)); | ||
161 | } | 147 | } |
162 | 148 | ||
163 | #[test] | 149 | #[test] |
@@ -1687,9 +1673,8 @@ fn test() { | |||
1687 | 1673 | ||
1688 | #[test] | 1674 | #[test] |
1689 | fn shadowing_primitive() { | 1675 | fn shadowing_primitive() { |
1690 | let t = type_at( | 1676 | check_types( |
1691 | r#" | 1677 | r#" |
1692 | //- /main.rs | ||
1693 | struct i32; | 1678 | struct i32; |
1694 | struct Foo; | 1679 | struct Foo; |
1695 | 1680 | ||
@@ -1697,15 +1682,15 @@ impl i32 { fn foo(&self) -> Foo { Foo } } | |||
1697 | 1682 | ||
1698 | fn main() { | 1683 | fn main() { |
1699 | let x: i32 = i32; | 1684 | let x: i32 = i32; |
1700 | x.foo()<|>; | 1685 | x.foo(); |
1686 | //^ Foo | ||
1701 | }"#, | 1687 | }"#, |
1702 | ); | 1688 | ); |
1703 | assert_eq!(t, "Foo"); | ||
1704 | } | 1689 | } |
1705 | 1690 | ||
1706 | #[test] | 1691 | #[test] |
1707 | fn not_shadowing_primitive_by_module() { | 1692 | fn not_shadowing_primitive_by_module() { |
1708 | let t = type_at( | 1693 | check_types( |
1709 | r#" | 1694 | r#" |
1710 | //- /str.rs | 1695 | //- /str.rs |
1711 | fn foo() {} | 1696 | fn foo() {} |
@@ -1715,15 +1700,15 @@ mod str; | |||
1715 | fn foo() -> &'static str { "" } | 1700 | fn foo() -> &'static str { "" } |
1716 | 1701 | ||
1717 | fn main() { | 1702 | fn main() { |
1718 | foo()<|>; | 1703 | foo(); |
1704 | //^ &str | ||
1719 | }"#, | 1705 | }"#, |
1720 | ); | 1706 | ); |
1721 | assert_eq!(t, "&str"); | ||
1722 | } | 1707 | } |
1723 | 1708 | ||
1724 | #[test] | 1709 | #[test] |
1725 | fn not_shadowing_module_by_primitive() { | 1710 | fn not_shadowing_module_by_primitive() { |
1726 | let t = type_at( | 1711 | check_types( |
1727 | r#" | 1712 | r#" |
1728 | //- /str.rs | 1713 | //- /str.rs |
1729 | fn foo() -> u32 {0} | 1714 | fn foo() -> u32 {0} |
@@ -1733,10 +1718,10 @@ mod str; | |||
1733 | fn foo() -> &'static str { "" } | 1718 | fn foo() -> &'static str { "" } |
1734 | 1719 | ||
1735 | fn main() { | 1720 | fn main() { |
1736 | str::foo()<|>; | 1721 | str::foo(); |
1722 | //^ u32 | ||
1737 | }"#, | 1723 | }"#, |
1738 | ); | 1724 | ); |
1739 | assert_eq!(t, "u32"); | ||
1740 | } | 1725 | } |
1741 | 1726 | ||
1742 | // This test is actually testing the shadowing behavior within ra_hir_def. It | 1727 | // This test is actually testing the shadowing behavior within ra_hir_def. It |
@@ -1744,27 +1729,7 @@ fn main() { | |||
1744 | // capable of asserting the necessary conditions. | 1729 | // capable of asserting the necessary conditions. |
1745 | #[test] | 1730 | #[test] |
1746 | fn should_be_shadowing_imports() { | 1731 | fn should_be_shadowing_imports() { |
1747 | let t = type_at( | 1732 | check_types( |
1748 | r#" | ||
1749 | mod a { | ||
1750 | pub fn foo() -> i8 {0} | ||
1751 | pub struct foo { a: i8 } | ||
1752 | } | ||
1753 | mod b { pub fn foo () -> u8 {0} } | ||
1754 | mod c { pub struct foo { a: u8 } } | ||
1755 | mod d { | ||
1756 | pub use super::a::*; | ||
1757 | pub use super::c::foo; | ||
1758 | pub use super::b::foo; | ||
1759 | } | ||
1760 | |||
1761 | fn main() { | ||
1762 | d::foo()<|>; | ||
1763 | }"#, | ||
1764 | ); | ||
1765 | assert_eq!(t, "u8"); | ||
1766 | |||
1767 | let t = type_at( | ||
1768 | r#" | 1733 | r#" |
1769 | mod a { | 1734 | mod a { |
1770 | pub fn foo() -> i8 {0} | 1735 | pub fn foo() -> i8 {0} |
@@ -1779,10 +1744,12 @@ mod d { | |||
1779 | } | 1744 | } |
1780 | 1745 | ||
1781 | fn main() { | 1746 | fn main() { |
1782 | d::foo{a:0<|>}; | 1747 | d::foo(); |
1748 | //^ u8 | ||
1749 | d::foo{a:0}; | ||
1750 | //^ u8 | ||
1783 | }"#, | 1751 | }"#, |
1784 | ); | 1752 | ); |
1785 | assert_eq!(t, "u8"); | ||
1786 | } | 1753 | } |
1787 | 1754 | ||
1788 | #[test] | 1755 | #[test] |
@@ -1880,6 +1847,7 @@ fn main() { | |||
1880 | @r###" | 1847 | @r###" |
1881 | 10..130 '{ ...2 }; }': () | 1848 | 10..130 '{ ...2 }; }': () |
1882 | 20..21 'x': i32 | 1849 | 20..21 'x': i32 |
1850 | 24..37 'unsafe { 92 }': i32 | ||
1883 | 31..37 '{ 92 }': i32 | 1851 | 31..37 '{ 92 }': i32 |
1884 | 33..35 '92': i32 | 1852 | 33..35 '92': i32 |
1885 | 47..48 'y': {unknown} | 1853 | 47..48 'y': {unknown} |
@@ -2151,3 +2119,48 @@ fn test() { | |||
2151 | "### | 2119 | "### |
2152 | ); | 2120 | ); |
2153 | } | 2121 | } |
2122 | |||
2123 | #[test] | ||
2124 | fn generic_default_depending_on_other_type_arg() { | ||
2125 | assert_snapshot!( | ||
2126 | infer(r#" | ||
2127 | struct Thing<T = u128, F = fn() -> T> { t: T } | ||
2128 | |||
2129 | fn test(t1: Thing<u32>, t2: Thing) { | ||
2130 | t1; | ||
2131 | t2; | ||
2132 | Thing::<_> { t: 1u32 }; | ||
2133 | } | ||
2134 | "#), | ||
2135 | // FIXME: the {unknown} is a bug | ||
2136 | @r###" | ||
2137 | 56..58 't1': Thing<u32, fn() -> u32> | ||
2138 | 72..74 't2': Thing<u128, fn() -> u128> | ||
2139 | 83..130 '{ ...2 }; }': () | ||
2140 | 89..91 't1': Thing<u32, fn() -> u32> | ||
2141 | 97..99 't2': Thing<u128, fn() -> u128> | ||
2142 | 105..127 'Thing:...1u32 }': Thing<u32, fn() -> {unknown}> | ||
2143 | 121..125 '1u32': u32 | ||
2144 | "### | ||
2145 | ); | ||
2146 | } | ||
2147 | |||
2148 | #[test] | ||
2149 | fn generic_default_depending_on_other_type_arg_forward() { | ||
2150 | assert_snapshot!( | ||
2151 | infer(r#" | ||
2152 | struct Thing<F = fn() -> T, T = u128> { t: T } | ||
2153 | |||
2154 | fn test(t1: Thing) { | ||
2155 | t1; | ||
2156 | } | ||
2157 | "#), | ||
2158 | // the {unknown} here is intentional, as defaults are not allowed to | ||
2159 | // refer to type parameters coming later | ||
2160 | @r###" | ||
2161 | 56..58 't1': Thing<fn() -> {unknown}, u128> | ||
2162 | 67..78 '{ t1; }': () | ||
2163 | 73..75 't1': Thing<fn() -> {unknown}, u128> | ||
2164 | "### | ||
2165 | ); | ||
2166 | } | ||
diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs index 71c0c2d27..01c919a7e 100644 --- a/crates/ra_hir_ty/src/tests/traits.rs +++ b/crates/ra_hir_ty/src/tests/traits.rs | |||
@@ -1,17 +1,13 @@ | |||
1 | use insta::assert_snapshot; | 1 | use insta::assert_snapshot; |
2 | use ra_db::fixture::WithFixture; | ||
3 | use test_utils::mark; | 2 | use test_utils::mark; |
4 | 3 | ||
5 | use crate::test_db::TestDB; | 4 | use super::{check_types, infer, infer_with_mismatches}; |
6 | |||
7 | use super::{infer, infer_with_mismatches, type_at, type_at_pos}; | ||
8 | 5 | ||
9 | #[test] | 6 | #[test] |
10 | fn infer_await() { | 7 | fn infer_await() { |
11 | let (db, pos) = TestDB::with_position( | 8 | check_types( |
12 | r#" | 9 | r#" |
13 | //- /main.rs crate:main deps:core | 10 | //- /main.rs crate:main deps:core |
14 | |||
15 | struct IntFuture; | 11 | struct IntFuture; |
16 | 12 | ||
17 | impl Future for IntFuture { | 13 | impl Future for IntFuture { |
@@ -21,8 +17,8 @@ impl Future for IntFuture { | |||
21 | fn test() { | 17 | fn test() { |
22 | let r = IntFuture; | 18 | let r = IntFuture; |
23 | let v = r.await; | 19 | let v = r.await; |
24 | v<|>; | 20 | v; |
25 | } | 21 | } //^ u64 |
26 | 22 | ||
27 | //- /core.rs crate:core | 23 | //- /core.rs crate:core |
28 | #[prelude_import] use future::*; | 24 | #[prelude_import] use future::*; |
@@ -32,18 +28,15 @@ mod future { | |||
32 | type Output; | 28 | type Output; |
33 | } | 29 | } |
34 | } | 30 | } |
35 | |||
36 | "#, | 31 | "#, |
37 | ); | 32 | ); |
38 | assert_eq!("u64", type_at_pos(&db, pos)); | ||
39 | } | 33 | } |
40 | 34 | ||
41 | #[test] | 35 | #[test] |
42 | fn infer_async() { | 36 | fn infer_async() { |
43 | let (db, pos) = TestDB::with_position( | 37 | check_types( |
44 | r#" | 38 | r#" |
45 | //- /main.rs crate:main deps:core | 39 | //- /main.rs crate:main deps:core |
46 | |||
47 | async fn foo() -> u64 { | 40 | async fn foo() -> u64 { |
48 | 128 | 41 | 128 |
49 | } | 42 | } |
@@ -51,8 +44,8 @@ async fn foo() -> u64 { | |||
51 | fn test() { | 44 | fn test() { |
52 | let r = foo(); | 45 | let r = foo(); |
53 | let v = r.await; | 46 | let v = r.await; |
54 | v<|>; | 47 | v; |
55 | } | 48 | } //^ u64 |
56 | 49 | ||
57 | //- /core.rs crate:core | 50 | //- /core.rs crate:core |
58 | #[prelude_import] use future::*; | 51 | #[prelude_import] use future::*; |
@@ -62,26 +55,23 @@ mod future { | |||
62 | type Output; | 55 | type Output; |
63 | } | 56 | } |
64 | } | 57 | } |
65 | |||
66 | "#, | 58 | "#, |
67 | ); | 59 | ); |
68 | assert_eq!("u64", type_at_pos(&db, pos)); | ||
69 | } | 60 | } |
70 | 61 | ||
71 | #[test] | 62 | #[test] |
72 | fn infer_desugar_async() { | 63 | fn infer_desugar_async() { |
73 | let (db, pos) = TestDB::with_position( | 64 | check_types( |
74 | r#" | 65 | r#" |
75 | //- /main.rs crate:main deps:core | 66 | //- /main.rs crate:main deps:core |
76 | |||
77 | async fn foo() -> u64 { | 67 | async fn foo() -> u64 { |
78 | 128 | 68 | 128 |
79 | } | 69 | } |
80 | 70 | ||
81 | fn test() { | 71 | fn test() { |
82 | let r = foo(); | 72 | let r = foo(); |
83 | r<|>; | 73 | r; |
84 | } | 74 | } //^ impl Future<Output = u64> |
85 | 75 | ||
86 | //- /core.rs crate:core | 76 | //- /core.rs crate:core |
87 | #[prelude_import] use future::*; | 77 | #[prelude_import] use future::*; |
@@ -93,23 +83,20 @@ mod future { | |||
93 | 83 | ||
94 | "#, | 84 | "#, |
95 | ); | 85 | ); |
96 | assert_eq!("impl Future<Output = u64>", type_at_pos(&db, pos)); | ||
97 | } | 86 | } |
98 | 87 | ||
99 | #[test] | 88 | #[test] |
100 | fn infer_try() { | 89 | fn infer_try() { |
101 | let (db, pos) = TestDB::with_position( | 90 | check_types( |
102 | r#" | 91 | r#" |
103 | //- /main.rs crate:main deps:core | 92 | //- /main.rs crate:main deps:core |
104 | |||
105 | fn test() { | 93 | fn test() { |
106 | let r: Result<i32, u64> = Result::Ok(1); | 94 | let r: Result<i32, u64> = Result::Ok(1); |
107 | let v = r?; | 95 | let v = r?; |
108 | v<|>; | 96 | v; |
109 | } | 97 | } //^ i32 |
110 | 98 | ||
111 | //- /core.rs crate:core | 99 | //- /core.rs crate:core |
112 | |||
113 | #[prelude_import] use ops::*; | 100 | #[prelude_import] use ops::*; |
114 | mod ops { | 101 | mod ops { |
115 | trait Try { | 102 | trait Try { |
@@ -130,30 +117,26 @@ mod result { | |||
130 | type Error = E; | 117 | type Error = E; |
131 | } | 118 | } |
132 | } | 119 | } |
133 | |||
134 | "#, | 120 | "#, |
135 | ); | 121 | ); |
136 | assert_eq!("i32", type_at_pos(&db, pos)); | ||
137 | } | 122 | } |
138 | 123 | ||
139 | #[test] | 124 | #[test] |
140 | fn infer_for_loop() { | 125 | fn infer_for_loop() { |
141 | let (db, pos) = TestDB::with_position( | 126 | check_types( |
142 | r#" | 127 | r#" |
143 | //- /main.rs crate:main deps:core,alloc | 128 | //- /main.rs crate:main deps:core,alloc |
144 | |||
145 | use alloc::collections::Vec; | 129 | use alloc::collections::Vec; |
146 | 130 | ||
147 | fn test() { | 131 | fn test() { |
148 | let v = Vec::new(); | 132 | let v = Vec::new(); |
149 | v.push("foo"); | 133 | v.push("foo"); |
150 | for x in v { | 134 | for x in v { |
151 | x<|>; | 135 | x; |
152 | } | 136 | } //^ &str |
153 | } | 137 | } |
154 | 138 | ||
155 | //- /core.rs crate:core | 139 | //- /core.rs crate:core |
156 | |||
157 | #[prelude_import] use iter::*; | 140 | #[prelude_import] use iter::*; |
158 | mod iter { | 141 | mod iter { |
159 | trait IntoIterator { | 142 | trait IntoIterator { |
@@ -162,7 +145,6 @@ mod iter { | |||
162 | } | 145 | } |
163 | 146 | ||
164 | //- /alloc.rs crate:alloc deps:core | 147 | //- /alloc.rs crate:alloc deps:core |
165 | |||
166 | mod collections { | 148 | mod collections { |
167 | struct Vec<T> {} | 149 | struct Vec<T> {} |
168 | impl<T> Vec<T> { | 150 | impl<T> Vec<T> { |
@@ -176,15 +158,13 @@ mod collections { | |||
176 | } | 158 | } |
177 | "#, | 159 | "#, |
178 | ); | 160 | ); |
179 | assert_eq!("&str", type_at_pos(&db, pos)); | ||
180 | } | 161 | } |
181 | 162 | ||
182 | #[test] | 163 | #[test] |
183 | fn infer_ops_neg() { | 164 | fn infer_ops_neg() { |
184 | let (db, pos) = TestDB::with_position( | 165 | check_types( |
185 | r#" | 166 | r#" |
186 | //- /main.rs crate:main deps:std | 167 | //- /main.rs crate:main deps:std |
187 | |||
188 | struct Bar; | 168 | struct Bar; |
189 | struct Foo; | 169 | struct Foo; |
190 | 170 | ||
@@ -195,11 +175,10 @@ impl std::ops::Neg for Bar { | |||
195 | fn test() { | 175 | fn test() { |
196 | let a = Bar; | 176 | let a = Bar; |
197 | let b = -a; | 177 | let b = -a; |
198 | b<|>; | 178 | b; |
199 | } | 179 | } //^ Foo |
200 | 180 | ||
201 | //- /std.rs crate:std | 181 | //- /std.rs crate:std |
202 | |||
203 | #[prelude_import] use ops::*; | 182 | #[prelude_import] use ops::*; |
204 | mod ops { | 183 | mod ops { |
205 | #[lang = "neg"] | 184 | #[lang = "neg"] |
@@ -209,15 +188,13 @@ mod ops { | |||
209 | } | 188 | } |
210 | "#, | 189 | "#, |
211 | ); | 190 | ); |
212 | assert_eq!("Foo", type_at_pos(&db, pos)); | ||
213 | } | 191 | } |
214 | 192 | ||
215 | #[test] | 193 | #[test] |
216 | fn infer_ops_not() { | 194 | fn infer_ops_not() { |
217 | let (db, pos) = TestDB::with_position( | 195 | check_types( |
218 | r#" | 196 | r#" |
219 | //- /main.rs crate:main deps:std | 197 | //- /main.rs crate:main deps:std |
220 | |||
221 | struct Bar; | 198 | struct Bar; |
222 | struct Foo; | 199 | struct Foo; |
223 | 200 | ||
@@ -228,11 +205,10 @@ impl std::ops::Not for Bar { | |||
228 | fn test() { | 205 | fn test() { |
229 | let a = Bar; | 206 | let a = Bar; |
230 | let b = !a; | 207 | let b = !a; |
231 | b<|>; | 208 | b; |
232 | } | 209 | } //^ Foo |
233 | 210 | ||
234 | //- /std.rs crate:std | 211 | //- /std.rs crate:std |
235 | |||
236 | #[prelude_import] use ops::*; | 212 | #[prelude_import] use ops::*; |
237 | mod ops { | 213 | mod ops { |
238 | #[lang = "not"] | 214 | #[lang = "not"] |
@@ -242,7 +218,6 @@ mod ops { | |||
242 | } | 218 | } |
243 | "#, | 219 | "#, |
244 | ); | 220 | ); |
245 | assert_eq!("Foo", type_at_pos(&db, pos)); | ||
246 | } | 221 | } |
247 | 222 | ||
248 | #[test] | 223 | #[test] |
@@ -537,10 +512,9 @@ fn indexing_arrays() { | |||
537 | 512 | ||
538 | #[test] | 513 | #[test] |
539 | fn infer_ops_index() { | 514 | fn infer_ops_index() { |
540 | let (db, pos) = TestDB::with_position( | 515 | check_types( |
541 | r#" | 516 | r#" |
542 | //- /main.rs crate:main deps:std | 517 | //- /main.rs crate:main deps:std |
543 | |||
544 | struct Bar; | 518 | struct Bar; |
545 | struct Foo; | 519 | struct Foo; |
546 | 520 | ||
@@ -551,11 +525,10 @@ impl std::ops::Index<u32> for Bar { | |||
551 | fn test() { | 525 | fn test() { |
552 | let a = Bar; | 526 | let a = Bar; |
553 | let b = a[1u32]; | 527 | let b = a[1u32]; |
554 | b<|>; | 528 | b; |
555 | } | 529 | } //^ Foo |
556 | 530 | ||
557 | //- /std.rs crate:std | 531 | //- /std.rs crate:std |
558 | |||
559 | #[prelude_import] use ops::*; | 532 | #[prelude_import] use ops::*; |
560 | mod ops { | 533 | mod ops { |
561 | #[lang = "index"] | 534 | #[lang = "index"] |
@@ -565,19 +538,18 @@ mod ops { | |||
565 | } | 538 | } |
566 | "#, | 539 | "#, |
567 | ); | 540 | ); |
568 | assert_eq!("Foo", type_at_pos(&db, pos)); | ||
569 | } | 541 | } |
570 | 542 | ||
571 | #[test] | 543 | #[test] |
572 | fn infer_ops_index_autoderef() { | 544 | fn infer_ops_index_autoderef() { |
573 | let (db, pos) = TestDB::with_position( | 545 | check_types( |
574 | r#" | 546 | r#" |
575 | //- /main.rs crate:main deps:std | 547 | //- /main.rs crate:main deps:std |
576 | fn test() { | 548 | fn test() { |
577 | let a = &[1u32, 2, 3]; | 549 | let a = &[1u32, 2, 3]; |
578 | let b = a[1u32]; | 550 | let b = a[1u32]; |
579 | b<|>; | 551 | b; |
580 | } | 552 | } //^ u32 |
581 | 553 | ||
582 | //- /std.rs crate:std | 554 | //- /std.rs crate:std |
583 | impl<T> ops::Index<u32> for [T] { | 555 | impl<T> ops::Index<u32> for [T] { |
@@ -593,14 +565,12 @@ mod ops { | |||
593 | } | 565 | } |
594 | "#, | 566 | "#, |
595 | ); | 567 | ); |
596 | assert_eq!("u32", type_at_pos(&db, pos)); | ||
597 | } | 568 | } |
598 | 569 | ||
599 | #[test] | 570 | #[test] |
600 | fn deref_trait() { | 571 | fn deref_trait() { |
601 | let t = type_at( | 572 | check_types( |
602 | r#" | 573 | r#" |
603 | //- /main.rs | ||
604 | #[lang = "deref"] | 574 | #[lang = "deref"] |
605 | trait Deref { | 575 | trait Deref { |
606 | type Target; | 576 | type Target; |
@@ -618,16 +588,15 @@ impl S { | |||
618 | } | 588 | } |
619 | 589 | ||
620 | fn test(s: Arc<S>) { | 590 | fn test(s: Arc<S>) { |
621 | (*s, s.foo())<|>; | 591 | (*s, s.foo()); |
622 | } | 592 | } //^ (S, u128) |
623 | "#, | 593 | "#, |
624 | ); | 594 | ); |
625 | assert_eq!(t, "(S, u128)"); | ||
626 | } | 595 | } |
627 | 596 | ||
628 | #[test] | 597 | #[test] |
629 | fn deref_trait_with_inference_var() { | 598 | fn deref_trait_with_inference_var() { |
630 | let t = type_at( | 599 | check_types( |
631 | r#" | 600 | r#" |
632 | //- /main.rs | 601 | //- /main.rs |
633 | #[lang = "deref"] | 602 | #[lang = "deref"] |
@@ -647,19 +616,18 @@ fn foo(a: Arc<S>) {} | |||
647 | 616 | ||
648 | fn test() { | 617 | fn test() { |
649 | let a = new_arc(); | 618 | let a = new_arc(); |
650 | let b = (*a)<|>; | 619 | let b = (*a); |
620 | //^ S | ||
651 | foo(a); | 621 | foo(a); |
652 | } | 622 | } |
653 | "#, | 623 | "#, |
654 | ); | 624 | ); |
655 | assert_eq!(t, "S"); | ||
656 | } | 625 | } |
657 | 626 | ||
658 | #[test] | 627 | #[test] |
659 | fn deref_trait_infinite_recursion() { | 628 | fn deref_trait_infinite_recursion() { |
660 | let t = type_at( | 629 | check_types( |
661 | r#" | 630 | r#" |
662 | //- /main.rs | ||
663 | #[lang = "deref"] | 631 | #[lang = "deref"] |
664 | trait Deref { | 632 | trait Deref { |
665 | type Target; | 633 | type Target; |
@@ -673,18 +641,16 @@ impl Deref for S { | |||
673 | } | 641 | } |
674 | 642 | ||
675 | fn test(s: S) { | 643 | fn test(s: S) { |
676 | s.foo()<|>; | 644 | s.foo(); |
677 | } | 645 | } //^ {unknown} |
678 | "#, | 646 | "#, |
679 | ); | 647 | ); |
680 | assert_eq!(t, "{unknown}"); | ||
681 | } | 648 | } |
682 | 649 | ||
683 | #[test] | 650 | #[test] |
684 | fn deref_trait_with_question_mark_size() { | 651 | fn deref_trait_with_question_mark_size() { |
685 | let t = type_at( | 652 | check_types( |
686 | r#" | 653 | r#" |
687 | //- /main.rs | ||
688 | #[lang = "deref"] | 654 | #[lang = "deref"] |
689 | trait Deref { | 655 | trait Deref { |
690 | type Target; | 656 | type Target; |
@@ -702,18 +668,16 @@ impl S { | |||
702 | } | 668 | } |
703 | 669 | ||
704 | fn test(s: Arc<S>) { | 670 | fn test(s: Arc<S>) { |
705 | (*s, s.foo())<|>; | 671 | (*s, s.foo()); |
706 | } | 672 | } //^ (S, u128) |
707 | "#, | 673 | "#, |
708 | ); | 674 | ); |
709 | assert_eq!(t, "(S, u128)"); | ||
710 | } | 675 | } |
711 | 676 | ||
712 | #[test] | 677 | #[test] |
713 | fn obligation_from_function_clause() { | 678 | fn obligation_from_function_clause() { |
714 | let t = type_at( | 679 | check_types( |
715 | r#" | 680 | r#" |
716 | //- /main.rs | ||
717 | struct S; | 681 | struct S; |
718 | 682 | ||
719 | trait Trait<T> {} | 683 | trait Trait<T> {} |
@@ -722,16 +686,15 @@ impl Trait<u32> for S {} | |||
722 | fn foo<T: Trait<U>, U>(t: T) -> U {} | 686 | fn foo<T: Trait<U>, U>(t: T) -> U {} |
723 | 687 | ||
724 | fn test(s: S) { | 688 | fn test(s: S) { |
725 | foo(s)<|>; | 689 | (foo(s)); |
726 | } | 690 | } //^ u32 |
727 | "#, | 691 | "#, |
728 | ); | 692 | ); |
729 | assert_eq!(t, "u32"); | ||
730 | } | 693 | } |
731 | 694 | ||
732 | #[test] | 695 | #[test] |
733 | fn obligation_from_method_clause() { | 696 | fn obligation_from_method_clause() { |
734 | let t = type_at( | 697 | check_types( |
735 | r#" | 698 | r#" |
736 | //- /main.rs | 699 | //- /main.rs |
737 | struct S; | 700 | struct S; |
@@ -745,18 +708,16 @@ impl O { | |||
745 | } | 708 | } |
746 | 709 | ||
747 | fn test() { | 710 | fn test() { |
748 | O.foo(S)<|>; | 711 | O.foo(S); |
749 | } | 712 | } //^ isize |
750 | "#, | 713 | "#, |
751 | ); | 714 | ); |
752 | assert_eq!(t, "isize"); | ||
753 | } | 715 | } |
754 | 716 | ||
755 | #[test] | 717 | #[test] |
756 | fn obligation_from_self_method_clause() { | 718 | fn obligation_from_self_method_clause() { |
757 | let t = type_at( | 719 | check_types( |
758 | r#" | 720 | r#" |
759 | //- /main.rs | ||
760 | struct S; | 721 | struct S; |
761 | 722 | ||
762 | trait Trait<T> {} | 723 | trait Trait<T> {} |
@@ -767,18 +728,16 @@ impl S { | |||
767 | } | 728 | } |
768 | 729 | ||
769 | fn test() { | 730 | fn test() { |
770 | S.foo()<|>; | 731 | S.foo(); |
771 | } | 732 | } //^ i64 |
772 | "#, | 733 | "#, |
773 | ); | 734 | ); |
774 | assert_eq!(t, "i64"); | ||
775 | } | 735 | } |
776 | 736 | ||
777 | #[test] | 737 | #[test] |
778 | fn obligation_from_impl_clause() { | 738 | fn obligation_from_impl_clause() { |
779 | let t = type_at( | 739 | check_types( |
780 | r#" | 740 | r#" |
781 | //- /main.rs | ||
782 | struct S; | 741 | struct S; |
783 | 742 | ||
784 | trait Trait<T> {} | 743 | trait Trait<T> {} |
@@ -790,32 +749,30 @@ impl<U, T: Trait<U>> O<T> { | |||
790 | } | 749 | } |
791 | 750 | ||
792 | fn test(o: O<S>) { | 751 | fn test(o: O<S>) { |
793 | o.foo()<|>; | 752 | o.foo(); |
794 | } | 753 | } //^ &str |
795 | "#, | 754 | "#, |
796 | ); | 755 | ); |
797 | assert_eq!(t, "&str"); | ||
798 | } | 756 | } |
799 | 757 | ||
800 | #[test] | 758 | #[test] |
801 | fn generic_param_env_1() { | 759 | fn generic_param_env_1() { |
802 | let t = type_at( | 760 | check_types( |
803 | r#" | 761 | r#" |
804 | //- /main.rs | ||
805 | trait Clone {} | 762 | trait Clone {} |
806 | trait Trait { fn foo(self) -> u128; } | 763 | trait Trait { fn foo(self) -> u128; } |
807 | struct S; | 764 | struct S; |
808 | impl Clone for S {} | 765 | impl Clone for S {} |
809 | impl<T> Trait for T where T: Clone {} | 766 | impl<T> Trait for T where T: Clone {} |
810 | fn test<T: Clone>(t: T) { t.foo()<|>; } | 767 | fn test<T: Clone>(t: T) { t.foo(); } |
768 | //^ u128 | ||
811 | "#, | 769 | "#, |
812 | ); | 770 | ); |
813 | assert_eq!(t, "u128"); | ||
814 | } | 771 | } |
815 | 772 | ||
816 | #[test] | 773 | #[test] |
817 | fn generic_param_env_1_not_met() { | 774 | fn generic_param_env_1_not_met() { |
818 | let t = type_at( | 775 | check_types( |
819 | r#" | 776 | r#" |
820 | //- /main.rs | 777 | //- /main.rs |
821 | trait Clone {} | 778 | trait Clone {} |
@@ -823,45 +780,42 @@ trait Trait { fn foo(self) -> u128; } | |||
823 | struct S; | 780 | struct S; |
824 | impl Clone for S {} | 781 | impl Clone for S {} |
825 | impl<T> Trait for T where T: Clone {} | 782 | impl<T> Trait for T where T: Clone {} |
826 | fn test<T>(t: T) { t.foo()<|>; } | 783 | fn test<T>(t: T) { t.foo(); } |
784 | //^ {unknown} | ||
827 | "#, | 785 | "#, |
828 | ); | 786 | ); |
829 | assert_eq!(t, "{unknown}"); | ||
830 | } | 787 | } |
831 | 788 | ||
832 | #[test] | 789 | #[test] |
833 | fn generic_param_env_2() { | 790 | fn generic_param_env_2() { |
834 | let t = type_at( | 791 | check_types( |
835 | r#" | 792 | r#" |
836 | //- /main.rs | ||
837 | trait Trait { fn foo(self) -> u128; } | 793 | trait Trait { fn foo(self) -> u128; } |
838 | struct S; | 794 | struct S; |
839 | impl Trait for S {} | 795 | impl Trait for S {} |
840 | fn test<T: Trait>(t: T) { t.foo()<|>; } | 796 | fn test<T: Trait>(t: T) { t.foo(); } |
797 | //^ u128 | ||
841 | "#, | 798 | "#, |
842 | ); | 799 | ); |
843 | assert_eq!(t, "u128"); | ||
844 | } | 800 | } |
845 | 801 | ||
846 | #[test] | 802 | #[test] |
847 | fn generic_param_env_2_not_met() { | 803 | fn generic_param_env_2_not_met() { |
848 | let t = type_at( | 804 | check_types( |
849 | r#" | 805 | r#" |
850 | //- /main.rs | ||
851 | trait Trait { fn foo(self) -> u128; } | 806 | trait Trait { fn foo(self) -> u128; } |
852 | struct S; | 807 | struct S; |
853 | impl Trait for S {} | 808 | impl Trait for S {} |
854 | fn test<T>(t: T) { t.foo()<|>; } | 809 | fn test<T>(t: T) { t.foo(); } |
810 | //^ {unknown} | ||
855 | "#, | 811 | "#, |
856 | ); | 812 | ); |
857 | assert_eq!(t, "{unknown}"); | ||
858 | } | 813 | } |
859 | 814 | ||
860 | #[test] | 815 | #[test] |
861 | fn generic_param_env_deref() { | 816 | fn generic_param_env_deref() { |
862 | let t = type_at( | 817 | check_types( |
863 | r#" | 818 | r#" |
864 | //- /main.rs | ||
865 | #[lang = "deref"] | 819 | #[lang = "deref"] |
866 | trait Deref { | 820 | trait Deref { |
867 | type Target; | 821 | type Target; |
@@ -870,17 +824,17 @@ trait Trait {} | |||
870 | impl<T> Deref for T where T: Trait { | 824 | impl<T> Deref for T where T: Trait { |
871 | type Target = i128; | 825 | type Target = i128; |
872 | } | 826 | } |
873 | fn test<T: Trait>(t: T) { (*t)<|>; } | 827 | fn test<T: Trait>(t: T) { (*t); } |
828 | //^ i128 | ||
874 | "#, | 829 | "#, |
875 | ); | 830 | ); |
876 | assert_eq!(t, "i128"); | ||
877 | } | 831 | } |
878 | 832 | ||
879 | #[test] | 833 | #[test] |
880 | fn associated_type_placeholder() { | 834 | fn associated_type_placeholder() { |
881 | let t = type_at( | 835 | // inside the generic function, the associated type gets normalized to a placeholder `ApplL::Out<T>` [https://rust-lang.github.io/rustc-guide/traits/associated-types.html#placeholder-associated-types]. |
836 | check_types( | ||
882 | r#" | 837 | r#" |
883 | //- /main.rs | ||
884 | pub trait ApplyL { | 838 | pub trait ApplyL { |
885 | type Out; | 839 | type Out; |
886 | } | 840 | } |
@@ -893,19 +847,16 @@ impl<T> ApplyL for RefMutL<T> { | |||
893 | 847 | ||
894 | fn test<T: ApplyL>() { | 848 | fn test<T: ApplyL>() { |
895 | let y: <RefMutL<T> as ApplyL>::Out = no_matter; | 849 | let y: <RefMutL<T> as ApplyL>::Out = no_matter; |
896 | y<|>; | 850 | y; |
897 | } | 851 | } //^ ApplyL::Out<T> |
898 | "#, | 852 | "#, |
899 | ); | 853 | ); |
900 | // inside the generic function, the associated type gets normalized to a placeholder `ApplL::Out<T>` [https://rust-lang.github.io/rustc-guide/traits/associated-types.html#placeholder-associated-types]. | ||
901 | assert_eq!(t, "ApplyL::Out<T>"); | ||
902 | } | 854 | } |
903 | 855 | ||
904 | #[test] | 856 | #[test] |
905 | fn associated_type_placeholder_2() { | 857 | fn associated_type_placeholder_2() { |
906 | let t = type_at( | 858 | check_types( |
907 | r#" | 859 | r#" |
908 | //- /main.rs | ||
909 | pub trait ApplyL { | 860 | pub trait ApplyL { |
910 | type Out; | 861 | type Out; |
911 | } | 862 | } |
@@ -913,11 +864,10 @@ fn foo<T: ApplyL>(t: T) -> <T as ApplyL>::Out; | |||
913 | 864 | ||
914 | fn test<T: ApplyL>(t: T) { | 865 | fn test<T: ApplyL>(t: T) { |
915 | let y = foo(t); | 866 | let y = foo(t); |
916 | y<|>; | 867 | y; |
917 | } | 868 | } //^ ApplyL::Out<T> |
918 | "#, | 869 | "#, |
919 | ); | 870 | ); |
920 | assert_eq!(t, "ApplyL::Out<T>"); | ||
921 | } | 871 | } |
922 | 872 | ||
923 | #[test] | 873 | #[test] |
@@ -1398,19 +1348,17 @@ fn test(a: impl Trait + 'lifetime, b: impl 'lifetime, c: impl (Trait), d: impl ( | |||
1398 | #[test] | 1348 | #[test] |
1399 | #[ignore] | 1349 | #[ignore] |
1400 | fn error_bound_chalk() { | 1350 | fn error_bound_chalk() { |
1401 | let t = type_at( | 1351 | check_types( |
1402 | r#" | 1352 | r#" |
1403 | //- /main.rs | ||
1404 | trait Trait { | 1353 | trait Trait { |
1405 | fn foo(&self) -> u32 {} | 1354 | fn foo(&self) -> u32 {} |
1406 | } | 1355 | } |
1407 | 1356 | ||
1408 | fn test(x: (impl Trait + UnknownTrait)) { | 1357 | fn test(x: (impl Trait + UnknownTrait)) { |
1409 | x.foo()<|>; | 1358 | x.foo(); |
1410 | } | 1359 | } //^ u32 |
1411 | "#, | 1360 | "#, |
1412 | ); | 1361 | ); |
1413 | assert_eq!(t, "u32"); | ||
1414 | } | 1362 | } |
1415 | 1363 | ||
1416 | #[test] | 1364 | #[test] |
@@ -1480,7 +1428,7 @@ fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) { | |||
1480 | 1428 | ||
1481 | #[test] | 1429 | #[test] |
1482 | fn impl_trait_assoc_binding_projection_bug() { | 1430 | fn impl_trait_assoc_binding_projection_bug() { |
1483 | let (db, pos) = TestDB::with_position( | 1431 | check_types( |
1484 | r#" | 1432 | r#" |
1485 | //- /main.rs crate:main deps:std | 1433 | //- /main.rs crate:main deps:std |
1486 | pub trait Language { | 1434 | pub trait Language { |
@@ -1499,8 +1447,8 @@ trait Clone { | |||
1499 | 1447 | ||
1500 | fn api_walkthrough() { | 1448 | fn api_walkthrough() { |
1501 | for node in foo() { | 1449 | for node in foo() { |
1502 | node.clone()<|>; | 1450 | node.clone(); |
1503 | } | 1451 | } //^ {unknown} |
1504 | } | 1452 | } |
1505 | 1453 | ||
1506 | //- /std.rs crate:std | 1454 | //- /std.rs crate:std |
@@ -1518,7 +1466,6 @@ mod iter { | |||
1518 | } | 1466 | } |
1519 | "#, | 1467 | "#, |
1520 | ); | 1468 | ); |
1521 | assert_eq!("{unknown}", type_at_pos(&db, pos)); | ||
1522 | } | 1469 | } |
1523 | 1470 | ||
1524 | #[test] | 1471 | #[test] |
@@ -1549,9 +1496,8 @@ fn test<T: Trait1<Type = u32>>(x: T) { | |||
1549 | 1496 | ||
1550 | #[test] | 1497 | #[test] |
1551 | fn where_clause_trait_in_scope_for_method_resolution() { | 1498 | fn where_clause_trait_in_scope_for_method_resolution() { |
1552 | let t = type_at( | 1499 | check_types( |
1553 | r#" | 1500 | r#" |
1554 | //- /main.rs | ||
1555 | mod foo { | 1501 | mod foo { |
1556 | trait Trait { | 1502 | trait Trait { |
1557 | fn foo(&self) -> u32 {} | 1503 | fn foo(&self) -> u32 {} |
@@ -1559,11 +1505,10 @@ mod foo { | |||
1559 | } | 1505 | } |
1560 | 1506 | ||
1561 | fn test<T: foo::Trait>(x: T) { | 1507 | fn test<T: foo::Trait>(x: T) { |
1562 | x.foo()<|>; | 1508 | x.foo(); |
1563 | } | 1509 | } //^ u32 |
1564 | "#, | 1510 | "#, |
1565 | ); | 1511 | ); |
1566 | assert_eq!(t, "u32"); | ||
1567 | } | 1512 | } |
1568 | 1513 | ||
1569 | #[test] | 1514 | #[test] |
@@ -2012,7 +1957,7 @@ fn test() { | |||
2012 | 1957 | ||
2013 | #[test] | 1958 | #[test] |
2014 | fn unselected_projection_in_trait_env_1() { | 1959 | fn unselected_projection_in_trait_env_1() { |
2015 | let t = type_at( | 1960 | check_types( |
2016 | r#" | 1961 | r#" |
2017 | //- /main.rs | 1962 | //- /main.rs |
2018 | trait Trait { | 1963 | trait Trait { |
@@ -2025,18 +1970,16 @@ trait Trait2 { | |||
2025 | 1970 | ||
2026 | fn test<T: Trait>() where T::Item: Trait2 { | 1971 | fn test<T: Trait>() where T::Item: Trait2 { |
2027 | let x: T::Item = no_matter; | 1972 | let x: T::Item = no_matter; |
2028 | x.foo()<|>; | 1973 | x.foo(); |
2029 | } | 1974 | } //^ u32 |
2030 | "#, | 1975 | "#, |
2031 | ); | 1976 | ); |
2032 | assert_eq!(t, "u32"); | ||
2033 | } | 1977 | } |
2034 | 1978 | ||
2035 | #[test] | 1979 | #[test] |
2036 | fn unselected_projection_in_trait_env_2() { | 1980 | fn unselected_projection_in_trait_env_2() { |
2037 | let t = type_at( | 1981 | check_types( |
2038 | r#" | 1982 | r#" |
2039 | //- /main.rs | ||
2040 | trait Trait<T> { | 1983 | trait Trait<T> { |
2041 | type Item; | 1984 | type Item; |
2042 | } | 1985 | } |
@@ -2047,11 +1990,10 @@ trait Trait2 { | |||
2047 | 1990 | ||
2048 | fn test<T, U>() where T::Item: Trait2, T: Trait<U::Item>, U: Trait<()> { | 1991 | fn test<T, U>() where T::Item: Trait2, T: Trait<U::Item>, U: Trait<()> { |
2049 | let x: T::Item = no_matter; | 1992 | let x: T::Item = no_matter; |
2050 | x.foo()<|>; | 1993 | x.foo(); |
2051 | } | 1994 | } //^ u32 |
2052 | "#, | 1995 | "#, |
2053 | ); | 1996 | ); |
2054 | assert_eq!(t, "u32"); | ||
2055 | } | 1997 | } |
2056 | 1998 | ||
2057 | #[test] | 1999 | #[test] |
@@ -2097,9 +2039,8 @@ impl Trait for S2 { | |||
2097 | 2039 | ||
2098 | #[test] | 2040 | #[test] |
2099 | fn unselected_projection_on_trait_self() { | 2041 | fn unselected_projection_on_trait_self() { |
2100 | let t = type_at( | 2042 | check_types( |
2101 | r#" | 2043 | r#" |
2102 | //- /main.rs | ||
2103 | trait Trait { | 2044 | trait Trait { |
2104 | type Item; | 2045 | type Item; |
2105 | 2046 | ||
@@ -2112,18 +2053,16 @@ impl Trait for S { | |||
2112 | } | 2053 | } |
2113 | 2054 | ||
2114 | fn test() { | 2055 | fn test() { |
2115 | S.f()<|>; | 2056 | S.f(); |
2116 | } | 2057 | } //^ u32 |
2117 | "#, | 2058 | "#, |
2118 | ); | 2059 | ); |
2119 | assert_eq!(t, "u32"); | ||
2120 | } | 2060 | } |
2121 | 2061 | ||
2122 | #[test] | 2062 | #[test] |
2123 | fn unselected_projection_chalk_fold() { | 2063 | fn unselected_projection_chalk_fold() { |
2124 | let t = type_at( | 2064 | check_types( |
2125 | r#" | 2065 | r#" |
2126 | //- /main.rs | ||
2127 | trait Interner {} | 2066 | trait Interner {} |
2128 | trait Fold<I: Interner, TI = I> { | 2067 | trait Fold<I: Interner, TI = I> { |
2129 | type Result; | 2068 | type Result; |
@@ -2142,18 +2081,16 @@ where | |||
2142 | } | 2081 | } |
2143 | 2082 | ||
2144 | fn foo<I: Interner>(interner: &I, t: Ty<I>) { | 2083 | fn foo<I: Interner>(interner: &I, t: Ty<I>) { |
2145 | fold(interner, t)<|>; | 2084 | fold(interner, t); |
2146 | } | 2085 | } //^ Ty<I> |
2147 | "#, | 2086 | "#, |
2148 | ); | 2087 | ); |
2149 | assert_eq!(t, "Ty<I>"); | ||
2150 | } | 2088 | } |
2151 | 2089 | ||
2152 | #[test] | 2090 | #[test] |
2153 | fn trait_impl_self_ty() { | 2091 | fn trait_impl_self_ty() { |
2154 | let t = type_at( | 2092 | check_types( |
2155 | r#" | 2093 | r#" |
2156 | //- /main.rs | ||
2157 | trait Trait<T> { | 2094 | trait Trait<T> { |
2158 | fn foo(&self); | 2095 | fn foo(&self); |
2159 | } | 2096 | } |
@@ -2163,18 +2100,16 @@ struct S; | |||
2163 | impl Trait<Self> for S {} | 2100 | impl Trait<Self> for S {} |
2164 | 2101 | ||
2165 | fn test() { | 2102 | fn test() { |
2166 | S.foo()<|>; | 2103 | S.foo(); |
2167 | } | 2104 | } //^ () |
2168 | "#, | 2105 | "#, |
2169 | ); | 2106 | ); |
2170 | assert_eq!(t, "()"); | ||
2171 | } | 2107 | } |
2172 | 2108 | ||
2173 | #[test] | 2109 | #[test] |
2174 | fn trait_impl_self_ty_cycle() { | 2110 | fn trait_impl_self_ty_cycle() { |
2175 | let t = type_at( | 2111 | check_types( |
2176 | r#" | 2112 | r#" |
2177 | //- /main.rs | ||
2178 | trait Trait { | 2113 | trait Trait { |
2179 | fn foo(&self); | 2114 | fn foo(&self); |
2180 | } | 2115 | } |
@@ -2184,18 +2119,17 @@ struct S<T>; | |||
2184 | impl Trait for S<Self> {} | 2119 | impl Trait for S<Self> {} |
2185 | 2120 | ||
2186 | fn test() { | 2121 | fn test() { |
2187 | S.foo()<|>; | 2122 | S.foo(); |
2188 | } | 2123 | } //^ {unknown} |
2189 | "#, | 2124 | "#, |
2190 | ); | 2125 | ); |
2191 | assert_eq!(t, "{unknown}"); | ||
2192 | } | 2126 | } |
2193 | 2127 | ||
2194 | #[test] | 2128 | #[test] |
2195 | fn unselected_projection_in_trait_env_cycle_1() { | 2129 | fn unselected_projection_in_trait_env_cycle_1() { |
2196 | let t = type_at( | 2130 | // this is a legitimate cycle |
2131 | check_types( | ||
2197 | r#" | 2132 | r#" |
2198 | //- /main.rs | ||
2199 | trait Trait { | 2133 | trait Trait { |
2200 | type Item; | 2134 | type Item; |
2201 | } | 2135 | } |
@@ -2203,17 +2137,16 @@ trait Trait { | |||
2203 | trait Trait2<T> {} | 2137 | trait Trait2<T> {} |
2204 | 2138 | ||
2205 | fn test<T: Trait>() where T: Trait2<T::Item> { | 2139 | fn test<T: Trait>() where T: Trait2<T::Item> { |
2206 | let x: T::Item = no_matter<|>; | 2140 | let x: T::Item = no_matter; |
2207 | } | 2141 | } //^ {unknown} |
2208 | "#, | 2142 | "#, |
2209 | ); | 2143 | ); |
2210 | // this is a legitimate cycle | ||
2211 | assert_eq!(t, "{unknown}"); | ||
2212 | } | 2144 | } |
2213 | 2145 | ||
2214 | #[test] | 2146 | #[test] |
2215 | fn unselected_projection_in_trait_env_cycle_2() { | 2147 | fn unselected_projection_in_trait_env_cycle_2() { |
2216 | let t = type_at( | 2148 | // this is a legitimate cycle |
2149 | check_types( | ||
2217 | r#" | 2150 | r#" |
2218 | //- /main.rs | 2151 | //- /main.rs |
2219 | trait Trait<T> { | 2152 | trait Trait<T> { |
@@ -2221,19 +2154,16 @@ trait Trait<T> { | |||
2221 | } | 2154 | } |
2222 | 2155 | ||
2223 | fn test<T, U>() where T: Trait<U::Item>, U: Trait<T::Item> { | 2156 | fn test<T, U>() where T: Trait<U::Item>, U: Trait<T::Item> { |
2224 | let x: T::Item = no_matter<|>; | 2157 | let x: T::Item = no_matter; |
2225 | } | 2158 | } //^ {unknown} |
2226 | "#, | 2159 | "#, |
2227 | ); | 2160 | ); |
2228 | // this is a legitimate cycle | ||
2229 | assert_eq!(t, "{unknown}"); | ||
2230 | } | 2161 | } |
2231 | 2162 | ||
2232 | #[test] | 2163 | #[test] |
2233 | fn inline_assoc_type_bounds_1() { | 2164 | fn inline_assoc_type_bounds_1() { |
2234 | let t = type_at( | 2165 | check_types( |
2235 | r#" | 2166 | r#" |
2236 | //- /main.rs | ||
2237 | trait Iterator { | 2167 | trait Iterator { |
2238 | type Item; | 2168 | type Item; |
2239 | } | 2169 | } |
@@ -2249,29 +2179,26 @@ impl<T: Iterator> Iterator for S<T> { | |||
2249 | 2179 | ||
2250 | fn test<I: Iterator<Item: OtherTrait<u32>>>() { | 2180 | fn test<I: Iterator<Item: OtherTrait<u32>>>() { |
2251 | let x: <S<I> as Iterator>::Item; | 2181 | let x: <S<I> as Iterator>::Item; |
2252 | x.foo()<|>; | 2182 | x.foo(); |
2253 | } | 2183 | } //^ u32 |
2254 | "#, | 2184 | "#, |
2255 | ); | 2185 | ); |
2256 | assert_eq!(t, "u32"); | ||
2257 | } | 2186 | } |
2258 | 2187 | ||
2259 | #[test] | 2188 | #[test] |
2260 | fn inline_assoc_type_bounds_2() { | 2189 | fn inline_assoc_type_bounds_2() { |
2261 | let t = type_at( | 2190 | check_types( |
2262 | r#" | 2191 | r#" |
2263 | //- /main.rs | ||
2264 | trait Iterator { | 2192 | trait Iterator { |
2265 | type Item; | 2193 | type Item; |
2266 | } | 2194 | } |
2267 | 2195 | ||
2268 | fn test<I: Iterator<Item: Iterator<Item = u32>>>() { | 2196 | fn test<I: Iterator<Item: Iterator<Item = u32>>>() { |
2269 | let x: <<I as Iterator>::Item as Iterator>::Item; | 2197 | let x: <<I as Iterator>::Item as Iterator>::Item; |
2270 | x<|>; | 2198 | x; |
2271 | } | 2199 | } //^ u32 |
2272 | "#, | 2200 | "#, |
2273 | ); | 2201 | ); |
2274 | assert_eq!(t, "u32"); | ||
2275 | } | 2202 | } |
2276 | 2203 | ||
2277 | #[test] | 2204 | #[test] |
@@ -2445,9 +2372,8 @@ fn main() { | |||
2445 | 2372 | ||
2446 | #[test] | 2373 | #[test] |
2447 | fn associated_type_bound() { | 2374 | fn associated_type_bound() { |
2448 | let t = type_at( | 2375 | check_types( |
2449 | r#" | 2376 | r#" |
2450 | //- /main.rs | ||
2451 | pub trait Trait { | 2377 | pub trait Trait { |
2452 | type Item: OtherTrait<u32>; | 2378 | type Item: OtherTrait<u32>; |
2453 | } | 2379 | } |
@@ -2463,18 +2389,16 @@ impl<T: Trait> Trait for S<T> { | |||
2463 | 2389 | ||
2464 | fn test<T: Trait>() { | 2390 | fn test<T: Trait>() { |
2465 | let y: <S<T> as Trait>::Item = no_matter; | 2391 | let y: <S<T> as Trait>::Item = no_matter; |
2466 | y.foo()<|>; | 2392 | y.foo(); |
2467 | } | 2393 | } //^ u32 |
2468 | "#, | 2394 | "#, |
2469 | ); | 2395 | ); |
2470 | assert_eq!(t, "u32"); | ||
2471 | } | 2396 | } |
2472 | 2397 | ||
2473 | #[test] | 2398 | #[test] |
2474 | fn dyn_trait_through_chalk() { | 2399 | fn dyn_trait_through_chalk() { |
2475 | let t = type_at( | 2400 | check_types( |
2476 | r#" | 2401 | r#" |
2477 | //- /main.rs | ||
2478 | struct Box<T> {} | 2402 | struct Box<T> {} |
2479 | #[lang = "deref"] | 2403 | #[lang = "deref"] |
2480 | trait Deref { | 2404 | trait Deref { |
@@ -2488,18 +2412,16 @@ trait Trait { | |||
2488 | } | 2412 | } |
2489 | 2413 | ||
2490 | fn test(x: Box<dyn Trait>) { | 2414 | fn test(x: Box<dyn Trait>) { |
2491 | x.foo()<|>; | 2415 | x.foo(); |
2492 | } | 2416 | } //^ () |
2493 | "#, | 2417 | "#, |
2494 | ); | 2418 | ); |
2495 | assert_eq!(t, "()"); | ||
2496 | } | 2419 | } |
2497 | 2420 | ||
2498 | #[test] | 2421 | #[test] |
2499 | fn string_to_owned() { | 2422 | fn string_to_owned() { |
2500 | let t = type_at( | 2423 | check_types( |
2501 | r#" | 2424 | r#" |
2502 | //- /main.rs | ||
2503 | struct String {} | 2425 | struct String {} |
2504 | pub trait ToOwned { | 2426 | pub trait ToOwned { |
2505 | type Owned; | 2427 | type Owned; |
@@ -2509,11 +2431,10 @@ impl ToOwned for str { | |||
2509 | type Owned = String; | 2431 | type Owned = String; |
2510 | } | 2432 | } |
2511 | fn test() { | 2433 | fn test() { |
2512 | "foo".to_owned()<|>; | 2434 | "foo".to_owned(); |
2513 | } | 2435 | } //^ String |
2514 | "#, | 2436 | "#, |
2515 | ); | 2437 | ); |
2516 | assert_eq!(t, "String"); | ||
2517 | } | 2438 | } |
2518 | 2439 | ||
2519 | #[test] | 2440 | #[test] |
@@ -2637,9 +2558,8 @@ fn main() { | |||
2637 | 2558 | ||
2638 | #[test] | 2559 | #[test] |
2639 | fn nested_assoc() { | 2560 | fn nested_assoc() { |
2640 | let t = type_at( | 2561 | check_types( |
2641 | r#" | 2562 | r#" |
2642 | //- /main.rs | ||
2643 | struct Bar; | 2563 | struct Bar; |
2644 | struct Foo; | 2564 | struct Foo; |
2645 | 2565 | ||
@@ -2662,11 +2582,10 @@ impl<T:A> B for T { | |||
2662 | } | 2582 | } |
2663 | 2583 | ||
2664 | fn main() { | 2584 | fn main() { |
2665 | Bar::foo()<|>; | 2585 | Bar::foo(); |
2666 | } | 2586 | } //^ Foo |
2667 | "#, | 2587 | "#, |
2668 | ); | 2588 | ); |
2669 | assert_eq!(t, "Foo"); | ||
2670 | } | 2589 | } |
2671 | 2590 | ||
2672 | #[test] | 2591 | #[test] |
@@ -2846,12 +2765,12 @@ fn test() { | |||
2846 | 2765 | ||
2847 | #[test] | 2766 | #[test] |
2848 | fn integer_range_iterate() { | 2767 | fn integer_range_iterate() { |
2849 | let t = type_at( | 2768 | check_types( |
2850 | r#" | 2769 | r#" |
2851 | //- /main.rs crate:main deps:core | 2770 | //- /main.rs crate:main deps:core |
2852 | fn test() { | 2771 | fn test() { |
2853 | for x in 0..100 { x<|>; } | 2772 | for x in 0..100 { x; } |
2854 | } | 2773 | } //^ i32 |
2855 | 2774 | ||
2856 | //- /core.rs crate:core | 2775 | //- /core.rs crate:core |
2857 | pub mod ops { | 2776 | pub mod ops { |
@@ -2886,7 +2805,6 @@ impl<A: Step> iter::Iterator for ops::Range<A> { | |||
2886 | } | 2805 | } |
2887 | "#, | 2806 | "#, |
2888 | ); | 2807 | ); |
2889 | assert_eq!(t, "i32"); | ||
2890 | } | 2808 | } |
2891 | 2809 | ||
2892 | #[test] | 2810 | #[test] |