use super::{infer, type_at, type_at_pos};
use crate::test_db::TestDB;
use insta::assert_snapshot;
use ra_db::fixture::WithFixture;
#[test]
fn infer_box() {
let (db, pos) = TestDB::with_position(
r#"
//- /main.rs crate:main deps:std
fn test() {
let x = box 1;
let t = (x, box x, box &1, box [1]);
t<|>;
}
//- /std.rs crate:std
#[prelude_import] use prelude::*;
mod prelude {}
mod boxed {
#[lang = "owned_box"]
pub struct Box<T: ?Sized> {
inner: *mut T,
}
}
"#,
);
assert_eq!("(Box<i32>, Box<Box<i32>>, Box<&i32>, Box<[i32; _]>)", type_at_pos(&db, pos));
}
#[test]
fn infer_adt_self() {
let (db, pos) = TestDB::with_position(
r#"
//- /main.rs
enum Nat { Succ(Self), Demo(Nat), Zero }
fn test() {
let foo: Nat = Nat::Zero;
if let Nat::Succ(x) = foo {
x<|>
}
}
"#,
);
assert_eq!("Nat", type_at_pos(&db, pos));
}
#[test]
fn self_in_struct_lit() {
assert_snapshot!(infer(
r#"
//- /main.rs
struct S<T> { x: T }
impl S<u32> {
fn foo() {
Self { x: 1 };
}
}
"#,
), @r###"
63..93 '{ ... }': ()
73..86 'Self { x: 1 }': S<u32>
83..84 '1': u32
"###);
}
#[test]
fn type_alias_in_struct_lit() {
assert_snapshot!(infer(
r#"
//- /main.rs
struct S<T> { x: T }
type SS = S<u32>;
fn foo() {
SS { x: 1 };
}
"#,
), @r###"
64..84 '{ ...1 }; }': ()
70..81 'SS { x: 1 }': S<u32>
78..79 '1': u32
"###);
}
#[test]
fn infer_ranges() {
let (db, pos) = TestDB::with_position(
r#"
//- /main.rs crate:main deps:std
fn test() {
let a = ..;
let b = 1..;
let c = ..2u32;
let d = 1..2usize;
let e = ..=10;
let f = 'a'..='z';
let t = (a, b, c, d, e, f);
t<|>;
}
//- /std.rs crate:std
#[prelude_import] use prelude::*;
mod prelude {}
pub mod ops {
pub struct Range<Idx> {
pub start: Idx,
pub end: Idx,
}
pub struct RangeFrom<Idx> {
pub start: Idx,
}
struct RangeFull;
pub struct RangeInclusive<Idx> {
start: Idx,
end: Idx,
is_empty: u8,
}
pub struct RangeTo<Idx> {
pub end: Idx,
}
pub struct RangeToInclusive<Idx> {
pub end: Idx,
}
}
"#,
);
assert_eq!(
"(RangeFull, RangeFrom<i32>, RangeTo<u32>, Range<usize>, RangeToInclusive<i32>, RangeInclusive<char>)",
type_at_pos(&db, pos),
);
}
#[test]
fn infer_while_let() {
let (db, pos) = TestDB::with_position(
r#"
//- /main.rs
enum Option<T> { Some(T), None }
fn test() {
let foo: Option<f32> = None;
while let Option::Some(x) = foo {
<|>x
}
}
"#,
);
assert_eq!("f32", type_at_pos(&db, pos));
}
#[test]
fn infer_basics() {
assert_snapshot!(
infer(r#"
fn test(a: u32, b: isize, c: !, d: &str) {
a;
b;
c;
d;
1usize;
1isize;
"test";
1.0f32;
}"#),
@r###"
9..10 'a': u32
17..18 'b': isize
27..28 'c': !
33..34 'd': &str
42..121 '{ ...f32; }': ()
48..49 'a': u32
55..56 'b': isize
62..63 'c': !
69..70 'd': &str
76..82 '1usize': usize
88..94 '1isize': isize
100..106 '"test"': &str
112..118 '1.0f32': f32
"###
);
}
#[test]
fn infer_let() {
assert_snapshot!(
infer(r#"
fn test() {
let a = 1isize;
let b: usize = 1;
let c = b;
let d: u32;
let e;
let f: i32 = e;
}
"#),
@r###"
11..118 '{ ...= e; }': ()
21..22 'a': isize
25..31 '1isize': isize
41..42 'b': usize
52..53 '1': usize
63..64 'c': usize
67..68 'b': usize
78..79 'd': u32
94..95 'e': i32
105..106 'f': i32
114..115 'e': i32
"###
);
}
#[test]
fn infer_paths() {
assert_snapshot!(
infer(r#"
fn a() -> u32 { 1 }
mod b {
fn c() -> u32 { 1 }
}
fn test() {
a();
b::c();
}
"#),
@r###"
15..20 '{ 1 }': u32
17..18 '1': u32
48..53 '{ 1 }': u32
50..51 '1': u32
67..91 '{ ...c(); }': ()
73..74 'a': fn a() -> u32
73..76 'a()': u32
82..86 'b::c': fn c() -> u32
82..88 'b::c()': u32
"###
);
}
#[test]
fn infer_path_type() {
assert_snapshot!(
infer(r#"
struct S;
impl S {
fn foo() -> i32 { 1 }
}
fn test() {
S::foo();
<S>::foo();
}
"#),
@r###"
41..46 '{ 1 }': i32
43..44 '1': i32
60..93 '{ ...o(); }': ()
66..72 'S::foo': fn foo() -> i32
66..74 'S::foo()': i32
80..88 '<S>::foo': fn foo() -> i32
80..90 '<S>::foo()': i32
"###
);
}
#[test]
fn infer_struct() {
assert_snapshot!(
infer(r#"
struct A {
b: B,
c: C,
}
struct B;
struct C(usize);
fn test() {
let c = C(1);
B;
let a: A = A { b: B, c: C(1) };
a.b;
a.c;
}
"#),
@r###"
72..154 '{ ...a.c; }': ()
82..83 'c': C
86..87 'C': C(usize) -> C
86..90 'C(1)': C
88..89 '1': usize
96..97 'B': B
107..108 'a': A
114..133 'A { b:...C(1) }': A
121..122 'B': B
127..128 'C': C(usize) -> C
127..131 'C(1)': C
129..130 '1': usize
139..140 'a': A
139..142 'a.b': B
148..149 'a': A
148..151 'a.c': C
"###
);
}
#[test]
fn infer_enum() {
assert_snapshot!(
infer(r#"
enum E {
V1 { field: u32 },
V2
}
fn test() {
E::V1 { field: 1 };
E::V2;
}"#),
@r###"
48..82 '{ E:...:V2; }': ()
52..70 'E::V1 ...d: 1 }': E
67..68 '1': u32
74..79 'E::V2': E
"###
);
}
#[test]
fn infer_refs() {
assert_snapshot!(
infer(r#"
fn test(a: &u32, b: &mut u32, c: *const u32, d: *mut u32) {
a;
*a;
&a;
&mut a;
b;
*b;
&b;
c;
*c;
d;
*d;
}
"#),
@r###"
9..10 'a': &u32
18..19 'b': &mut u32
31..32 'c': *const u32
46..47 'd': *mut u32
59..150 '{ ... *d; }': ()
65..66 'a': &u32
72..74 '*a': u32
73..74 'a': &u32
80..82 '&a': &&u32
81..82 'a': &u32
88..94 '&mut a': &mut &u32
93..94 'a': &u32
100..101 'b': &mut u32
107..109 '*b': u32
108..109 'b': &mut u32
115..117 '&b': &&mut u32
116..117 'b': &mut u32
123..124 'c': *const u32
130..132 '*c': u32
131..132 'c': *const u32
138..139 'd': *mut u32
145..147 '*d': u32
146..147 'd': *mut u32
"###
);
}
#[test]
fn infer_raw_ref() {
assert_snapshot!(
infer(r#"
fn test(a: i32) {
&raw mut a;
&raw const a;
}
"#),
@r###"
9..10 'a': i32
17..54 '{ ...t a; }': ()
23..33 '&raw mut a': *mut i32
32..33 'a': i32
39..51 '&raw const a': *const i32
50..51 'a': i32
"###
);
}
#[test]
fn infer_literals() {
assert_snapshot!(
infer(r##"
fn test() {
5i32;
5f32;
5f64;
"hello";
b"bytes";
'c';
b'b';
3.14;
5000;
false;
true;
r#"
//! doc
// non-doc
mod foo {}
"#;
br#"yolo"#;
}
"##),
@r###"
11..221 '{ ...o"#; }': ()
17..21 '5i32': i32
27..31 '5f32': f32
37..41 '5f64': f64
47..54 '"hello"': &str
60..68 'b"bytes"': &[u8; _]
74..77 ''c'': char
83..87 'b'b'': u8
93..97 '3.14': f64
103..107 '5000': i32
113..118 'false': bool
124..128 'true': bool
134..202 'r#" ... "#': &str
208..218 'br#"yolo"#': &[u8; _]
"###
);
}
#[test]
fn infer_unary_op() {
assert_snapshot!(
infer(r#"
enum SomeType {}
fn test(x: SomeType) {
let b = false;
let c = !b;
let a = 100;
let d: i128 = -a;
let e = -100;
let f = !!!true;
let g = !42;
let h = !10u32;
let j = !a;
-3.14;
!3;
-x;
!x;
-"hello";
!"hello";
}
"#),
@r###"
27..28 'x': SomeType
40..272 '{ ...lo"; }': ()
50..51 'b': bool
54..59 'false': bool
69..70 'c': bool
73..75 '!b': bool
74..75 'b': bool
85..86 'a': i128
89..92 '100': i128
102..103 'd': i128
112..114 '-a': i128
113..114 'a': i128
124..125 'e': i32
128..132 '-100': i32
129..132 '100': i32
142..143 'f': bool
146..153 '!!!true': bool
147..153 '!!true': bool
148..153 '!true': bool
149..153 'true': bool
163..164 'g': i32
167..170 '!42': i32
168..170 '42': i32
180..181 'h': u32
184..190 '!10u32': u32
185..190 '10u32': u32
200..201 'j': i128
204..206 '!a': i128
205..206 'a': i128
212..217 '-3.14': f64
213..217 '3.14': f64
223..225 '!3': i32
224..225 '3': i32
231..233 '-x': {unknown}
232..233 'x': SomeType
239..241 '!x': {unknown}
240..241 'x': SomeType
247..255 '-"hello"': {unknown}
248..255 '"hello"': &str
261..269 '!"hello"': {unknown}
262..269 '"hello"': &str
"###
);
}
#[test]
fn infer_backwards() {
assert_snapshot!(
infer(r#"
fn takes_u32(x: u32) {}
struct S { i32_field: i32 }
fn test() -> &mut &f64 {
let a = unknown_function();
takes_u32(a);
let b = unknown_function();
S { i32_field: b };
let c = unknown_function();
&mut &c
}
"#),
@r###"
14..15 'x': u32
22..24 '{}': ()
78..231 '{ ...t &c }': &mut &f64
88..89 'a': u32
92..108 'unknow...nction': {unknown}
92..110 'unknow...tion()': u32
116..125 'takes_u32': fn takes_u32(u32)
116..128 'takes_u32(a)': ()
126..127 'a': u32
138..139 'b': i32
142..158 'unknow...nction': {unknown}
142..160 'unknow...tion()': i32
166..184 'S { i3...d: b }': S
181..182 'b': i32
194..195 'c': f64
198..214 'unknow...nction': {unknown}
198..216 'unknow...tion()': f64
222..229 '&mut &c': &mut &f64
227..229 '&c': &f64
228..229 'c': f64
"###
);
}
#[test]
fn infer_self() {
assert_snapshot!(
infer(r#"
struct S;
impl S {
fn test(&self) {
self;
}
fn test2(self: &Self) {
self;
}
fn test3() -> Self {
S {}
}
fn test4() -> Self {
Self {}
}
}
"#),
@r###"
34..38 'self': &S
40..61 '{ ... }': ()
50..54 'self': &S
75..79 'self': &S
88..109 '{ ... }': ()
98..102 'self': &S
133..153 '{ ... }': S
143..147 'S {}': S
177..200 '{ ... }': S
187..194 'Self {}': S
"###
);
}
#[test]
fn infer_self_as_path() {
assert_snapshot!(
infer(r#"
struct S1;
struct S2(isize);
enum E {
V1,
V2(u32),
}
impl S1 {
fn test() {
Self;
}
}
impl S2 {
fn test() {
Self(1);
}
}
impl E {
fn test() {
Self::V1;
Self::V2(1);
}
}
"#),
@r###"
87..108 '{ ... }': ()
97..101 'Self': S1
135..159 '{ ... }': ()
145..149 'Self': S2(isize) -> S2
145..152 'Self(1)': S2
150..151 '1': isize
185..231 '{ ... }': ()
195..203 'Self::V1': E
213..221 'Self::V2': V2(u32) -> E
213..224 'Self::V2(1)': E
222..223 '1': u32
"###
);
}
#[test]
fn infer_binary_op() {
assert_snapshot!(
infer(r#"
fn f(x: bool) -> i32 {
0i32
}
fn test() -> bool {
let x = a && b;
let y = true || false;
let z = x == y;
let t = x != y;
let minus_forty: isize = -40isize;
let h = minus_forty <= CONST_2;
let c = f(z || y) + 5;
let d = b;
let g = minus_forty ^= i;
let ten: usize = 10;
let ten_is_eleven = ten == some_num;
ten < 3
}
"#),
@r###"
6..7 'x': bool
22..34 '{ 0i32 }': i32
28..32 '0i32': i32
54..370 '{ ... < 3 }': bool
64..65 'x': bool
68..69 'a': bool
68..74 'a && b': bool
73..74 'b': bool
84..85 'y': bool
88..92 'true': bool
88..101 'true || false': bool
96..101 'false': bool
111..112 'z': bool
115..116 'x': bool
115..121 'x == y': bool
120..121 'y': bool
131..132 't': bool
135..136 'x': bool
135..141 'x != y': bool
140..141 'y': bool
151..162 'minus_forty': isize
172..180 '-40isize': isize
173..180 '40isize': isize
190..191 'h': bool
194..205 'minus_forty': isize
194..216 'minus_...ONST_2': bool
209..216 'CONST_2': isize
226..227 'c': i32
230..231 'f': fn f(bool) -> i32
230..239 'f(z || y)': i32
230..243 'f(z || y) + 5': i32
232..233 'z': bool
232..238 'z || y': bool
237..238 'y': bool
242..243 '5': i32
253..254 'd': {unknown}
257..258 'b': {unknown}
268..269 'g': ()
272..283 'minus_forty': isize
272..288 'minus_...y ^= i': ()
287..288 'i': isize
298..301 'ten': usize
311..313 '10': usize
323..336 'ten_is_eleven': bool
339..342 'ten': usize
339..354 'ten == some_num': bool
346..354 'some_num': usize
361..364 'ten': usize
361..368 'ten < 3': bool
367..368 '3': usize
"###
);
}
#[test]
fn infer_shift_op() {
assert_snapshot!(
infer(r#"
fn test() {
1u32 << 5u8;
1u32 >> 5u8;
}
"#),
@r###"
11..48 '{ ...5u8; }': ()
17..21 '1u32': u32
17..28 '1u32 << 5u8': u32
25..28 '5u8': u8
34..38 '1u32': u32
34..45 '1u32 >> 5u8': u32
42..45 '5u8': u8
"###
);
}
#[test]
fn infer_field_autoderef() {
assert_snapshot!(
infer(r#"
struct A {
b: B,
}
struct B;
fn test1(a: A) {
let a1 = a;
a1.b;
let a2 = &a;
a2.b;
let a3 = &mut a;
a3.b;
let a4 = &&&&&&&a;
a4.b;
let a5 = &mut &&mut &&mut a;
a5.b;
}
fn test2(a1: *const A, a2: *mut A) {
a1.b;
a2.b;
}
"#),
@r###"
44..45 'a': A
50..213 '{ ...5.b; }': ()
60..62 'a1': A
65..66 'a': A
72..74 'a1': A
72..76 'a1.b': B
86..88 'a2': &A
91..93 '&a': &A
92..93 'a': A
99..101 'a2': &A
99..103 'a2.b': B
113..115 'a3': &mut A
118..124 '&mut a': &mut A
123..124 'a': A
130..132 'a3': &mut A
130..134 'a3.b': B
144..146 'a4': &&&&&&&A
149..157 '&&&&&&&a': &&&&&&&A
150..157 '&&&&&&a': &&&&&&A
151..157 '&&&&&a': &&&&&A
152..157 '&&&&a': &&&&A
153..157 '&&&a': &&&A
154..157 '&&a': &&A
155..157 '&a': &A
156..157 'a': A
163..165 'a4': &&&&&&&A
163..167 'a4.b': B
177..179 'a5': &mut &&mut &&mut A
182..200 '&mut &...&mut a': &mut &&mut &&mut A
187..200 '&&mut &&mut a': &&mut &&mut A
188..200 '&mut &&mut a': &mut &&mut A
193..200 '&&mut a': &&mut A
194..200 '&mut a': &mut A
199..200 'a': A
206..208 'a5': &mut &&mut &&mut A
206..210 'a5.b': B
224..226 'a1': *const A
238..240 'a2': *mut A
250..273 '{ ...2.b; }': ()
256..258 'a1': *const A
256..260 'a1.b': B
266..268 'a2': *mut A
266..270 'a2.b': B
"###
);
}
#[test]
fn infer_argument_autoderef() {
assert_snapshot!(
infer(r#"
#[lang = "deref"]
pub trait Deref {
type Target;
fn deref(&self) -> &Self::Target;
}
struct A<T>(T);
impl<T> A<T> {
fn foo(&self) -> &T {
&self.0
}
}
struct B<T>(T);
impl<T> Deref for B<T> {
type Target = T;
fn deref(&self) -> &Self::Target {
&self.0
}
}
fn test() {
let t = A::foo(&&B(B(A(42))));
}
"#),
@r###"
68..72 'self': &Self
139..143 'self': &A<T>
151..174 '{ ... }': &T
161..168 '&self.0': &T
162..166 'self': &A<T>
162..168 'self.0': T
255..259 'self': &B<T>
278..301 '{ ... }': &T
288..295 '&self.0': &T
289..293 'self': &B<T>
289..295 'self.0': T
315..353 '{ ...))); }': ()
325..326 't': &i32
329..335 'A::foo': fn foo<i32>(&A<i32>) -> &i32
329..350 'A::foo...42))))': &i32
336..349 '&&B(B(A(42)))': &&B<B<A<i32>>>
337..349 '&B(B(A(42)))': &B<B<A<i32>>>
338..339 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
338..349 'B(B(A(42)))': B<B<A<i32>>>
340..341 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
340..348 'B(A(42))': B<A<i32>>
342..343 'A': A<i32>(i32) -> A<i32>
342..347 'A(42)': A<i32>
344..346 '42': i32
"###
);
}
#[test]
fn infer_method_argument_autoderef() {
assert_snapshot!(
infer(r#"
#[lang = "deref"]
pub trait Deref {
type Target;
fn deref(&self) -> &Self::Target;
}
struct A<T>(*mut T);
impl<T> A<T> {
fn foo(&self, x: &A<T>) -> &T {
&*x.0
}
}
struct B<T>(T);
impl<T> Deref for B<T> {
type Target = T;
fn deref(&self) -> &Self::Target {
&self.0
}
}
fn test(a: A<i32>) {
let t = A(0 as *mut _).foo(&&B(B(a)));
}
"#),
@r###"
68..72 'self': &Self
144..148 'self': &A<T>
150..151 'x': &A<T>
166..187 '{ ... }': &T
176..181 '&*x.0': &T
177..181 '*x.0': T
178..179 'x': &A<T>
178..181 'x.0': *mut T
268..272 'self': &B<T>
291..314 '{ ... }': &T
301..308 '&self.0': &T
302..306 'self': &B<T>
302..308 'self.0': T
326..327 'a': A<i32>
337..383 '{ ...))); }': ()
347..348 't': &i32
351..352 'A': A<i32>(*mut i32) -> A<i32>
351..365 'A(0 as *mut _)': A<i32>
351..380 'A(0 as...B(a)))': &i32
353..354 '0': i32
353..364 '0 as *mut _': *mut i32
370..379 '&&B(B(a))': &&B<B<A<i32>>>
371..379 '&B(B(a))': &B<B<A<i32>>>
372..373 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
372..379 'B(B(a))': B<B<A<i32>>>
374..375 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
374..378 'B(a)': B<A<i32>>
376..377 'a': A<i32>
"###
);
}
#[test]
fn infer_in_elseif() {
assert_snapshot!(
infer(r#"
struct Foo { field: i32 }
fn main(foo: Foo) {
if true {
} else if false {
foo.field
}
}
"#),
@r###"
35..38 'foo': Foo
45..109 '{ ... } }': ()
51..107 'if tru... }': ()
54..58 'true': bool
59..67 '{ }': ()
73..107 'if fal... }': i32
76..81 'false': bool
82..107 '{ ... }': i32
92..95 'foo': Foo
92..101 'foo.field': i32
"###
)
}
#[test]
fn infer_if_match_with_return() {
assert_snapshot!(
infer(r#"
fn foo() {
let _x1 = if true {
1
} else {
return;
};
let _x2 = if true {
2
} else {
return
};
let _x3 = match true {
true => 3,
_ => {
return;
}
};
let _x4 = match true {
true => 4,
_ => return
};
}"#),
@r###"
10..323 '{ ... }; }': ()
20..23 '_x1': i32
26..80 'if tru... }': i32
29..33 'true': bool
34..51 '{ ... }': i32
44..45 '1': i32
57..80 '{ ... }': i32
67..73 'return': !
90..93 '_x2': i32
96..149 'if tru... }': i32
99..103 'true': bool
104..121 '{ ... }': i32
114..115 '2': i32
127..149 '{ ... }': !
137..143 'return': !
159..162 '_x3': i32
165..247 'match ... }': i32
171..175 'true': bool
186..190 'true': bool
186..190 'true': bool
194..195 '3': i32
205..206 '_': bool
210..241 '{ ... }': i32
224..230 'return': !
257..260 '_x4': i32
263..320 'match ... }': i32
269..273 'true': bool
284..288 'true': bool
284..288 'true': bool
292..293 '4': i32
303..304 '_': bool
308..314 'return': !
"###
)
}
#[test]
fn infer_inherent_method() {
assert_snapshot!(
infer(r#"
struct A;
impl A {
fn foo(self, x: u32) -> i32 {}
}
mod b {
impl super::A {
fn bar(&self, x: u64) -> i64 {}
}
}
fn test(a: A) {
a.foo(1);
(&a).bar(1);
a.bar(1);
}
"#),
@r###"
32..36 'self': A
38..39 'x': u32
53..55 '{}': ()
103..107 'self': &A
109..110 'x': u64
124..126 '{}': ()
144..145 'a': A
150..198 '{ ...(1); }': ()
156..157 'a': A
156..164 'a.foo(1)': i32
162..163 '1': u32
170..181 '(&a).bar(1)': i64
171..173 '&a': &A
172..173 'a': A
179..180 '1': u64
187..188 'a': A
187..195 'a.bar(1)': i64
193..194 '1': u64
"###
);
}
#[test]
fn infer_inherent_method_str() {
assert_snapshot!(
infer(r#"
#[lang = "str"]
impl str {
fn foo(&self) -> i32 {}
}
fn test() {
"foo".foo();
}
"#),
@r###"
40..44 'self': &str
53..55 '{}': ()
69..89 '{ ...o(); }': ()
75..80 '"foo"': &str
75..86 '"foo".foo()': i32
"###
);
}
#[test]
fn infer_tuple() {
assert_snapshot!(
infer(r#"
fn test(x: &str, y: isize) {
let a: (u32, &str) = (1, "a");
let b = (a, x);
let c = (y, x);
let d = (c, x);
let e = (1, "e");
let f = (e, "d");
}
"#),
@r###"
9..10 'x': &str
18..19 'y': isize
28..170 '{ ...d"); }': ()
38..39 'a': (u32, &str)
55..63 '(1, "a")': (u32, &str)
56..57 '1': u32
59..62 '"a"': &str
73..74 'b': ((u32, &str), &str)
77..83 '(a, x)': ((u32, &str), &str)
78..79 'a': (u32, &str)
81..82 'x': &str
93..94 'c': (isize, &str)
97..103 '(y, x)': (isize, &str)
98..99 'y': isize
101..102 'x': &str
113..114 'd': ((isize, &str), &str)
117..123 '(c, x)': ((isize, &str), &str)
118..119 'c': (isize, &str)
121..122 'x': &str
133..134 'e': (i32, &str)
137..145 '(1, "e")': (i32, &str)
138..139 '1': i32
141..144 '"e"': &str
155..156 'f': ((i32, &str), &str)
159..167 '(e, "d")': ((i32, &str), &str)
160..161 'e': (i32, &str)
163..166 '"d"': &str
"###
);
}
#[test]
fn infer_array() {
assert_snapshot!(
infer(r#"
fn test(x: &str, y: isize) {
let a = [x];
let b = [a, a];
let c = [b, b];
let d = [y, 1, 2, 3];
let d = [1, y, 2, 3];
let e = [y];
let f = [d, d];
let g = [e, e];
let h = [1, 2];
let i = ["a", "b"];
let b = [a, ["b"]];
let x: [u8; 0] = [];
}
"#),
@r###"
9..10 'x': &str
18..19 'y': isize
28..293 '{ ... []; }': ()
38..39 'a': [&str; _]
42..45 '[x]': [&str; _]
43..44 'x': &str
55..56 'b': [[&str; _]; _]
59..65 '[a, a]': [[&str; _]; _]
60..61 'a': [&str; _]
63..64 'a': [&str; _]
75..76 'c': [[[&str; _]; _]; _]
79..85 '[b, b]': [[[&str; _]; _]; _]
80..81 'b': [[&str; _]; _]
83..84 'b': [[&str; _]; _]
96..97 'd': [isize; _]
100..112 '[y, 1, 2, 3]': [isize; _]
101..102 'y': isize
104..105 '1': isize
107..108 '2': isize
110..111 '3': isize
122..123 'd': [isize; _]
126..138 '[1, y, 2, 3]': [isize; _]
127..128 '1': isize
130..131 'y': isize
133..134 '2': isize
136..137 '3': isize
148..149 'e': [isize; _]
152..155 '[y]': [isize; _]
153..154 'y': isize
165..166 'f': [[isize; _]; _]
169..175 '[d, d]': [[isize; _]; _]
170..171 'd': [isize; _]
173..174 'd': [isize; _]
185..186 'g': [[isize; _]; _]
189..195 '[e, e]': [[isize; _]; _]
190..191 'e': [isize; _]
193..194 'e': [isize; _]
206..207 'h': [i32; _]
210..216 '[1, 2]': [i32; _]
211..212 '1': i32
214..215 '2': i32
226..227 'i': [&str; _]
230..240 '["a", "b"]': [&str; _]
231..234 '"a"': &str
236..239 '"b"': &str
251..252 'b': [[&str; _]; _]
255..265 '[a, ["b"]]': [[&str; _]; _]
256..257 'a': [&str; _]
259..264 '["b"]': [&str; _]
260..263 '"b"': &str
275..276 'x': [u8; _]
288..290 '[]': [u8; _]
"###
);
}
#[test]
fn infer_struct_generics() {
assert_snapshot!(
infer(r#"
struct A<T> {
x: T,
}
fn test(a1: A<u32>, i: i32) {
a1.x;
let a2 = A { x: i };
a2.x;
let a3 = A::<i128> { x: 1 };
a3.x;
}
"#),
@r###"
36..38 'a1': A<u32>
48..49 'i': i32
56..147 '{ ...3.x; }': ()
62..64 'a1': A<u32>
62..66 'a1.x': u32
76..78 'a2': A<i32>
81..91 'A { x: i }': A<i32>
88..89 'i': i32
97..99 'a2': A<i32>
97..101 'a2.x': i32
111..113 'a3': A<i128>
116..134 'A::<i1...x: 1 }': A<i128>
131..132 '1': i128
140..142 'a3': A<i128>
140..144 'a3.x': i128
"###
);
}
#[test]
fn infer_tuple_struct_generics() {
assert_snapshot!(
infer(r#"
struct A<T>(T);
enum Option<T> { Some(T), None }
use Option::*;
fn test() {
A(42);
A(42u128);
Some("x");
Option::Some("x");
None;
let x: Option<i64> = None;
}
"#),
@r###"
76..184 '{ ...one; }': ()
82..83 'A': A<i32>(i32) -> A<i32>
82..87 'A(42)': A<i32>
84..86 '42': i32
93..94 'A': A<u128>(u128) -> A<u128>
93..102 'A(42u128)': A<u128>
95..101 '42u128': u128
108..112 'Some': Some<&str>(&str) -> Option<&str>
108..117 'Some("x")': Option<&str>
113..116 '"x"': &str
123..135 'Option::Some': Some<&str>(&str) -> Option<&str>
123..140 'Option...e("x")': Option<&str>
136..139 '"x"': &str
146..150 'None': Option<{unknown}>
160..161 'x': Option<i64>
177..181 'None': Option<i64>
"###
);
}
#[test]
fn infer_function_generics() {
assert_snapshot!(
infer(r#"
fn id<T>(t: T) -> T { t }
fn test() {
id(1u32);
id::<i128>(1);
let x: u64 = id(1);
}
"#),
@r###"
10..11 't': T
21..26 '{ t }': T
23..24 't': T
38..98 '{ ...(1); }': ()
44..46 'id': fn id<u32>(u32) -> u32
44..52 'id(1u32)': u32
47..51 '1u32': u32
58..68 'id::<i128>': fn id<i128>(i128) -> i128
58..71 'id::<i128>(1)': i128
69..70 '1': i128
81..82 'x': u64
90..92 'id': fn id<u64>(u64) -> u64
90..95 'id(1)': u64
93..94 '1': u64
"###
);
}
#[test]
fn infer_impl_generics_basic() {
assert_snapshot!(
infer(r#"
struct A<T1, T2> {
x: T1,
y: T2,
}
impl<Y, X> A<X, Y> {
fn x(self) -> X {
self.x
}
fn y(self) -> Y {
self.y
}
fn z<T>(self, t: T) -> (X, Y, T) {
(self.x, self.y, t)
}
}
fn test() -> i128 {
let a = A { x: 1u64, y: 1i64 };
a.x();
a.y();
a.z(1i128);
a.z::<u128>(1);
}
"#),
@r###"
74..78 'self': A<X, Y>
85..107 '{ ... }': X
95..99 'self': A<X, Y>
95..101 'self.x': X
117..121 'self': A<X, Y>
128..150 '{ ... }': Y
138..142 'self': A<X, Y>
138..144 'self.y': Y
163..167 'self': A<X, Y>
169..170 't': T
188..223 '{ ... }': (X, Y, T)
198..217 '(self.....y, t)': (X, Y, T)
199..203 'self': A<X, Y>
199..205 'self.x': X
207..211 'self': A<X, Y>
207..213 'self.y': Y
215..216 't': T
245..342 '{ ...(1); }': ()
255..256 'a': A<u64, i64>
259..281 'A { x:...1i64 }': A<u64, i64>
266..270 '1u64': u64
275..279 '1i64': i64
287..288 'a': A<u64, i64>
287..292 'a.x()': u64
298..299 'a': A<u64, i64>
298..303 'a.y()': i64
309..310 'a': A<u64, i64>
309..319 'a.z(1i128)': (u64, i64, i128)
313..318 '1i128': i128
325..326 'a': A<u64, i64>
325..339 'a.z::<u128>(1)': (u64, i64, u128)
337..338 '1': u128
"###
);
}
#[test]
fn infer_impl_generics_with_autoderef() {
assert_snapshot!(
infer(r#"
enum Option<T> {
Some(T),
None,
}
impl<T> Option<T> {
fn as_ref(&self) -> Option<&T> {}
}
fn test(o: Option<u32>) {
(&o).as_ref();
o.as_ref();
}
"#),
@r###"
78..82 'self': &Option<T>
98..100 '{}': ()
111..112 'o': Option<u32>
127..165 '{ ...f(); }': ()
133..146 '(&o).as_ref()': Option<&u32>
134..136 '&o': &Option<u32>
135..136 'o': Option<u32>
152..153 'o': Option<u32>
152..162 'o.as_ref()': Option<&u32>
"###
);
}
#[test]
fn infer_generic_chain() {
assert_snapshot!(
infer(r#"
struct A<T> {
x: T,
}
impl<T2> A<T2> {
fn x(self) -> T2 {
self.x
}
}
fn id<T>(t: T) -> T { t }
fn test() -> i128 {
let x = 1;
let y = id(x);
let a = A { x: id(y) };
let z = id(a.x);
let b = A { x: z };
b.x()
}
"#),
@r###"
53..57 'self': A<T2>
65..87 '{ ... }': T2
75..79 'self': A<T2>
75..81 'self.x': T2
99..100 't': T
110..115 '{ t }': T
112..113 't': T
135..261 '{ ....x() }': i128
146..147 'x': i128
150..151 '1': i128
162..163 'y': i128
166..168 'id': fn id<i128>(i128) -> i128
166..171 'id(x)': i128
169..170 'x': i128
182..183 'a': A<i128>
186..200 'A { x: id(y) }': A<i128>
193..195 'id': fn id<i128>(i128) -> i128
193..198 'id(y)': i128
196..197 'y': i128
211..212 'z': i128
215..217 'id': fn id<i128>(i128) -> i128
215..222 'id(a.x)': i128
218..219 'a': A<i128>
218..221 'a.x': i128
233..234 'b': A<i128>
237..247 'A { x: z }': A<i128>
244..245 'z': i128
254..255 'b': A<i128>
254..259 'b.x()': i128
"###
);
}
#[test]
fn infer_associated_const() {
assert_snapshot!(
infer(r#"
struct Struct;
impl Struct {
const FOO: u32 = 1;
}
enum Enum {}
impl Enum {
const BAR: u32 = 2;
}
trait Trait {
const ID: u32;
}
struct TraitTest;
impl Trait for TraitTest {
const ID: u32 = 5;
}
fn test() {
let x = Struct::FOO;
let y = Enum::BAR;
let z = TraitTest::ID;
}
"#),
@r###"
52..53 '1': u32
105..106 '2': u32
213..214 '5': u32
229..307 '{ ...:ID; }': ()
239..240 'x': u32
243..254 'Struct::FOO': u32
264..265 'y': u32
268..277 'Enum::BAR': u32
287..288 'z': u32
291..304 'TraitTest::ID': u32
"###
);
}
#[test]
fn infer_type_alias() {
assert_snapshot!(
infer(r#"
struct A<X, Y> { x: X, y: Y }
type Foo = A<u32, i128>;
type Bar<T> = A<T, u128>;
type Baz<U, V> = A<V, U>;
fn test(x: Foo, y: Bar<&str>, z: Baz<i8, u8>) {
x.x;
x.y;
y.x;
y.y;
z.x;
z.y;
}
"#),
@r###"
116..117 'x': A<u32, i128>
124..125 'y': A<&str, u128>
138..139 'z': A<u8, i8>
154..211 '{ ...z.y; }': ()
160..161 'x': A<u32, i128>
160..163 'x.x': u32
169..170 'x': A<u32, i128>
169..172 'x.y': i128
178..179 'y': A<&str, u128>
178..181 'y.x': &str
187..188 'y': A<&str, u128>
187..190 'y.y': u128
196..197 'z': A<u8, i8>
196..199 'z.x': u8
205..206 'z': A<u8, i8>
205..208 'z.y': i8
"###
)
}
#[test]
fn recursive_type_alias() {
assert_snapshot!(
infer(r#"
struct A<X> {}
type Foo = Foo;
type Bar = A<Bar>;
fn test(x: Foo) {}
"#),
@r###"
59..60 'x': {unknown}
67..69 '{}': ()
"###
)
}
#[test]
fn infer_type_param() {
assert_snapshot!(
infer(r#"
fn id<T>(x: T) -> T {
x
}
fn clone<T>(x: &T) -> T {
*x
}
fn test() {
let y = 10u32;
id(y);
let x: bool = clone(z);
id::<i128>(1);
}
"#),
@r###"
10..11 'x': T
21..30 '{ x }': T
27..28 'x': T
44..45 'x': &T
56..66 '{ *x }': T
62..64 '*x': T
63..64 'x': &T
78..158 '{ ...(1); }': ()
88..89 'y': u32
92..97 '10u32': u32
103..105 'id': fn id<u32>(u32) -> u32
103..108 'id(y)': u32
106..107 'y': u32
118..119 'x': bool
128..133 'clone': fn clone<bool>(&bool) -> bool
128..136 'clone(z)': bool
134..135 'z': &bool
142..152 'id::<i128>': fn id<i128>(i128) -> i128
142..155 'id::<i128>(1)': i128
153..154 '1': i128
"###
);
}
#[test]
fn infer_const() {
assert_snapshot!(
infer(r#"
struct Foo;
impl Foo { const ASSOC_CONST: u32 = 0; }
const GLOBAL_CONST: u32 = 101;
fn test() {
const LOCAL_CONST: u32 = 99;
let x = LOCAL_CONST;
let z = GLOBAL_CONST;
let id = Foo::ASSOC_CONST;
}
"#),
@r###"
49..50 '0': u32
80..83 '101': u32
95..213 '{ ...NST; }': ()
138..139 'x': u32
142..153 'LOCAL_CONST': u32
163..164 'z': u32
167..179 'GLOBAL_CONST': u32
189..191 'id': u32
194..210 'Foo::A..._CONST': u32
126..128 '99': u32
"###
);
}
#[test]
fn infer_static() {
assert_snapshot!(
infer(r#"
static GLOBAL_STATIC: u32 = 101;
static mut GLOBAL_STATIC_MUT: u32 = 101;
fn test() {
static LOCAL_STATIC: u32 = 99;
static mut LOCAL_STATIC_MUT: u32 = 99;
let x = LOCAL_STATIC;
let y = LOCAL_STATIC_MUT;
let z = GLOBAL_STATIC;
let w = GLOBAL_STATIC_MUT;
}
"#),
@r###"
29..32 '101': u32
70..73 '101': u32
85..280 '{ ...MUT; }': ()
173..174 'x': u32
177..189 'LOCAL_STATIC': u32
199..200 'y': u32
203..219 'LOCAL_...IC_MUT': u32
229..230 'z': u32
233..246 'GLOBAL_STATIC': u32
256..257 'w': u32
260..277 'GLOBAL...IC_MUT': u32
118..120 '99': u32
161..163 '99': u32
"###
);
}
#[test]
fn shadowing_primitive() {
let t = type_at(
r#"
//- /main.rs
struct i32;
struct Foo;
impl i32 { fn foo(&self) -> Foo { Foo } }
fn main() {
let x: i32 = i32;
x.foo()<|>;
}"#,
);
assert_eq!(t, "Foo");
}
#[test]
fn not_shadowing_primitive_by_module() {
let t = type_at(
r#"
//- /str.rs
fn foo() {}
//- /main.rs
mod str;
fn foo() -> &'static str { "" }
fn main() {
foo()<|>;
}"#,
);
assert_eq!(t, "&str");
}
#[test]
fn not_shadowing_module_by_primitive() {
let t = type_at(
r#"
//- /str.rs
fn foo() -> u32 {0}
//- /main.rs
mod str;
fn foo() -> &'static str { "" }
fn main() {
str::foo()<|>;
}"#,
);
assert_eq!(t, "u32");
}
#[test]
fn closure_return() {
assert_snapshot!(
infer(r#"
fn foo() -> u32 {
let x = || -> usize { return 1; };
}
"#),
@r###"
17..59 '{ ...; }; }': ()
27..28 'x': || -> usize
31..56 '|| -> ...n 1; }': || -> usize
43..56 '{ return 1; }': usize
45..53 'return 1': !
52..53 '1': usize
"###
);
}
#[test]
fn closure_return_unit() {
assert_snapshot!(
infer(r#"
fn foo() -> u32 {
let x = || { return; };
}
"#),
@r###"
17..48 '{ ...; }; }': ()
27..28 'x': || -> ()
31..45 '|| { return; }': || -> ()
34..45 '{ return; }': ()
36..42 'return': !
"###
);
}
#[test]
fn closure_return_inferred() {
assert_snapshot!(
infer(r#"
fn foo() -> u32 {
let x = || { "test" };
}
"#),
@r###"
17..47 '{ ..." }; }': ()
27..28 'x': || -> &str
31..44 '|| { "test" }': || -> &str
34..44 '{ "test" }': &str
36..42 '"test"': &str
"###
);
}
#[test]
fn fn_pointer_return() {
assert_snapshot!(
infer(r#"
struct Vtable {
method: fn(),
}
fn main() {
let vtable = Vtable { method: || {} };
let m = vtable.method;
}
"#),
@r###"
48..121 '{ ...hod; }': ()
58..64 'vtable': Vtable
67..91 'Vtable...| {} }': Vtable
84..89 '|| {}': || -> ()
87..89 '{}': ()
101..102 'm': fn()
105..111 'vtable': Vtable
105..118 'vtable.method': fn()
"###
);
}
#[test]
fn effects_smoke_test() {
assert_snapshot!(
infer(r#"
fn main() {
let x = unsafe { 92 };
let y = async { async { () }.await };
let z = try { () };
let t = 'a: { 92 };
}
"#),
@r###"
11..131 '{ ...2 }; }': ()
21..22 'x': i32
32..38 '{ 92 }': i32
34..36 '92': i32
48..49 'y': {unknown}
58..80 '{ asyn...wait }': {unknown}
60..78 'async ....await': {unknown}
66..72 '{ () }': ()
68..70 '()': ()
90..91 'z': {unknown}
94..104 'try { () }': {unknown}
98..104 '{ () }': ()
100..102 '()': ()
114..115 't': i32
122..128 '{ 92 }': i32
124..126 '92': i32
"###
)
}
#[test]
fn infer_generic_from_later_assignment() {
assert_snapshot!(
infer(r#"
enum Option<T> { Some(T), None }
use Option::*;
fn test() {
let mut end = None;
loop {
end = Some(true);
}
}
"#),
@r###"
60..130 '{ ... } }': ()
70..77 'mut end': Option<bool>
80..84 'None': Option<bool>
90..128 'loop {... }': !
95..128 '{ ... }': ()
105..108 'end': Option<bool>
105..121 'end = ...(true)': ()
111..115 'Some': Some<bool>(bool) -> Option<bool>
111..121 'Some(true)': Option<bool>
116..120 'true': bool
"###
);
}
#[test]
fn infer_loop_break_with_val() {
assert_snapshot!(
infer(r#"
enum Option<T> { Some(T), None }
use Option::*;
fn test() {
let x = loop {
if false {
break None;
}
break Some(true);
};
}
"#),
@r###"
60..169 '{ ... }; }': ()
70..71 'x': Option<bool>
74..166 'loop {... }': Option<bool>
79..166 '{ ... }': ()
89..133 'if fal... }': ()
92..97 'false': bool
98..133 '{ ... }': ()
112..122 'break None': !
118..122 'None': Option<bool>
143..159 'break ...(true)': !
149..153 'Some': Some<bool>(bool) -> Option<bool>
149..159 'Some(true)': Option<bool>
154..158 'true': bool
"###
);
}
#[test]
fn infer_loop_break_without_val() {
assert_snapshot!(
infer(r#"
enum Option<T> { Some(T), None }
use Option::*;
fn test() {
let x = loop {
if false {
break;
}
};
}
"#),
@r###"
60..137 '{ ... }; }': ()
70..71 'x': ()
74..134 'loop {... }': ()
79..134 '{ ... }': ()
89..128 'if fal... }': ()
92..97 'false': bool
98..128 '{ ... }': ()
112..117 'break': !
"###
);
}
#[test]
fn infer_labelled_break_with_val() {
assert_snapshot!(
infer(r#"
fn foo() {
let _x = || 'outer: loop {
let inner = 'inner: loop {
let i = Default::default();
if (break 'outer i) {
loop { break 'inner 5i8; };
} else if true {
break 'inner 6;
}
break 7;
};
break inner < 8;
};
}
"#),
@r###"
10..336 '{ ... }; }': ()
20..22 '_x': || -> bool
25..333 '|| 'ou... }': || -> bool
28..333 ''outer... }': bool
41..333 '{ ... }': ()
55..60 'inner': i8
63..301 ''inner... }': i8
76..301 '{ ... }': ()
94..95 'i': bool
98..114 'Defaul...efault': {unknown}
98..116 'Defaul...ault()': bool
130..270 'if (br... }': ()
134..148 'break 'outer i': !
147..148 'i': bool
150..209 '{ ... }': ()
168..194 'loop {...5i8; }': !
173..194 '{ brea...5i8; }': ()
175..191 'break ...er 5i8': !
188..191 '5i8': i8
215..270 'if tru... }': ()
218..222 'true': bool
223..270 '{ ... }': ()
241..255 'break 'inner 6': !
254..255 '6': i8
283..290 'break 7': !
289..290 '7': i8
311..326 'break inner < 8': !
317..322 'inner': i8
317..326 'inner < 8': bool
325..326 '8': i8
"###
);
}
#[test]
fn generic_default() {
assert_snapshot!(
infer(r#"
struct Thing<T = ()> { t: T }
enum OtherThing<T = ()> {
One { t: T },
Two(T),
}
fn test(t1: Thing, t2: OtherThing, t3: Thing<i32>, t4: OtherThing<i32>) {
t1.t;
t3.t;
match t2 {
OtherThing::One { t } => { t; },
OtherThing::Two(t) => { t; },
}
match t4 {
OtherThing::One { t } => { t; },
OtherThing::Two(t) => { t; },
}
}
"#),
@r###"
98..100 't1': Thing<()>
109..111 't2': OtherThing<()>
125..127 't3': Thing<i32>
141..143 't4': OtherThing<i32>
162..385 '{ ... } }': ()
168..170 't1': Thing<()>
168..172 't1.t': ()
178..180 't3': Thing<i32>
178..182 't3.t': i32
188..283 'match ... }': ()
194..196 't2': OtherThing<()>
207..228 'OtherT... { t }': OtherThing<()>
225..226 't': ()
232..238 '{ t; }': ()
234..235 't': ()
248..266 'OtherT...Two(t)': OtherThing<()>
264..265 't': ()
270..276 '{ t; }': ()
272..273 't': ()
288..383 'match ... }': ()
294..296 't4': OtherThing<i32>
307..328 'OtherT... { t }': OtherThing<i32>
325..326 't': i32
332..338 '{ t; }': ()
334..335 't': i32
348..366 'OtherT...Two(t)': OtherThing<i32>
364..365 't': i32
370..376 '{ t; }': ()
372..373 't': i32
"###
);
}
#[test]
fn generic_default_in_struct_literal() {
assert_snapshot!(
infer(r#"
struct Thing<T = ()> { t: T }
enum OtherThing<T = ()> {
One { t: T },
Two(T),
}
fn test() {
let x = Thing { t: loop {} };
let y = Thing { t: () };
let z = Thing { t: 1i32 };
if let Thing { t } = z {
t;
}
let a = OtherThing::One { t: 1i32 };
let b = OtherThing::Two(1i32);
}
"#),
@r###"
100..320 '{ ...32); }': ()
110..111 'x': Thing<!>
114..134 'Thing ...p {} }': Thing<!>
125..132 'loop {}': !
130..132 '{}': ()
144..145 'y': Thing<()>
148..163 'Thing { t: () }': Thing<()>
159..161 '()': ()
173..174 'z': Thing<i32>
177..194 'Thing ...1i32 }': Thing<i32>
188..192 '1i32': i32
200..241 'if let... }': ()
207..218 'Thing { t }': Thing<i32>
215..216 't': i32
221..222 'z': Thing<i32>
223..241 '{ ... }': ()
233..234 't': i32
251..252 'a': OtherThing<i32>
255..282 'OtherT...1i32 }': OtherThing<i32>
276..280 '1i32': i32
292..293 'b': OtherThing<i32>
296..311 'OtherThing::Two': Two<i32>(i32) -> OtherThing<i32>
296..317 'OtherT...(1i32)': OtherThing<i32>
312..316 '1i32': i32
"###
);
}