diff options
author | bors[bot] <26634292+bors[bot]@users.noreply.github.com> | 2020-06-29 16:25:12 +0100 |
---|---|---|
committer | GitHub <[email protected]> | 2020-06-29 16:25:12 +0100 |
commit | 32ee06032785ea1792144f7263cbce93a4de467b (patch) | |
tree | fac101a18e111a2a05bce14fbb68981c5bef3bfd /crates/ra_hir_ty/src/tests/traits.rs | |
parent | 82ce5792ab70ab8d20a1afde72c5400c27b9c190 (diff) | |
parent | bbc4dc995612916a4c0a99396b5259a5fb1dda80 (diff) |
Merge #5127
5127: Update the rest of the tests r=matklad a=matklad
bors r+
🤖
Co-authored-by: Aleksey Kladov <[email protected]>
Diffstat (limited to 'crates/ra_hir_ty/src/tests/traits.rs')
-rw-r--r-- | crates/ra_hir_ty/src/tests/traits.rs | 342 |
1 files changed, 130 insertions, 212 deletions
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] |