use expect_test::expect;
use super::{check, check_infer, check_infer_with_mismatches, check_no_mismatches, check_types};
#[test]
fn infer_pattern() {
check_infer(
r#"
//- minicore: iterator, add, builtin_impls
fn test(x: &i32) {
let y = x;
let &z = x;
let a = z;
let (c, d) = (1, "hello");
for (e, f) in [(0, 1)] {
let g = e;
}
if let [val] = [y] {
let h = val;
}
if let x @ true = &true {}
let lambda = |a: u64, b, c: i32| { a + b; c };
let ref ref_to_x = x;
let mut mut_x = x;
let ref mut mut_ref_to_x = x;
let k = mut_ref_to_x;
}
"#,
expect![[r#"
8..9 'x': &'? i32
17..399 '{ ...o_x; }': ()
27..28 'y': &'? i32
31..32 'x': &'? i32
42..44 '&z': &'? i32
43..44 'z': i32
47..48 'x': &'? i32
58..59 'a': i32
62..63 'z': i32
73..79 '(c, d)': (i32, &'? str)
74..75 'c': i32
77..78 'd': &'? str
82..94 '(1, "hello")': (i32, &'? str)
83..84 '1': i32
86..93 '"hello"': &'static str
101..150 'for (e... }': fn into_iter<[(i32, i32); 1]>([(i32, i32); 1]) -> <[(i32, i32); 1] as IntoIterator>::IntoIter
101..150 'for (e... }': IntoIter<(i32, i32), 1>
101..150 'for (e... }': !
101..150 'for (e... }': IntoIter<(i32, i32), 1>
101..150 'for (e... }': &'? mut IntoIter<(i32, i32), 1>
101..150 'for (e... }': fn next<IntoIter<(i32, i32), 1>>(&'? mut IntoIter<(i32, i32), 1>) -> Option<<IntoIter<(i32, i32), 1> as Iterator>::Item>
101..150 'for (e... }': Option<(i32, i32)>
101..150 'for (e... }': ()
101..150 'for (e... }': ()
101..150 'for (e... }': ()
101..150 'for (e... }': ()
105..111 '(e, f)': (i32, i32)
106..107 'e': i32
109..110 'f': i32
115..123 '[(0, 1)]': [(i32, i32); 1]
116..122 '(0, 1)': (i32, i32)
117..118 '0': i32
120..121 '1': i32
124..150 '{ ... }': ()
138..139 'g': i32
142..143 'e': i32
156..203 'if let... }': ()
159..174 'let [val] = [y]': bool
163..168 '[val]': [&'? i32; 1]
164..167 'val': &'? i32
171..174 '[y]': [&'? i32; 1]
172..173 'y': &'? i32
175..203 '{ ... }': ()
189..190 'h': &'? i32
193..196 'val': &'? i32
209..235 'if let...rue {}': ()
212..232 'let x ... &true': bool
216..224 'x @ true': &'? bool
220..224 'true': bool
220..224 'true': bool
227..232 '&true': &'? bool
228..232 'true': bool
233..235 '{}': ()
245..251 'lambda': impl Fn(u64, u64, i32) -> i32
254..286 '|a: u6...b; c }': impl Fn(u64, u64, i32) -> i32
255..256 'a': u64
263..264 'b': u64
266..267 'c': i32
274..286 '{ a + b; c }': i32
276..277 'a': u64
276..281 'a + b': u64
280..281 'b': u64
283..284 'c': i32
297..309 'ref ref_to_x': &'? &'? i32
312..313 'x': &'? i32
323..332 'mut mut_x': &'? i32
335..336 'x': &'? i32
346..366 'ref mu...f_to_x': &'? mut &'? i32
369..370 'x': &'? i32
380..381 'k': &'? mut &'? i32
384..396 'mut_ref_to_x': &'? mut &'? i32
"#]],
);
}
#[test]
fn infer_literal_pattern() {
check_infer_with_mismatches(
r#"
fn any<T>() -> T { loop {} }
fn test(x: &i32) {
if let "foo" = any() {}
if let 1 = any() {}
if let 1u32 = any() {}
if let 1f16 = any() {}
if let 1f32 = any() {}
if let 1.0 = any() {}
if let 1f128 = any() {}
if let true = any() {}
}
"#,
expect![[r#"
17..28 '{ loop {} }': T
19..26 'loop {}': !
24..26 '{}': ()
37..38 'x': &'? i32
46..263 '{ ...) {} }': ()
52..75 'if let...y() {}': ()
55..72 'let "f... any()': bool
59..64 '"foo"': &'static str
59..64 '"foo"': &'static str
67..70 'any': fn any<&'static str>() -> &'static str
67..72 'any()': &'static str
73..75 '{}': ()
80..99 'if let...y() {}': ()
83..96 'let 1 = any()': bool
87..88 '1': i32
87..88 '1': i32
91..94 'any': fn any<i32>() -> i32
91..96 'any()': i32
97..99 '{}': ()
104..126 'if let...y() {}': ()
107..123 'let 1u... any()': bool
111..115 '1u32': u32
111..115 '1u32': u32
118..121 'any': fn any<u32>() -> u32
118..123 'any()': u32
124..126 '{}': ()
131..153 'if let...y() {}': ()
134..150 'let 1f... any()': bool
138..142 '1f16': f16
138..142 '1f16': f16
145..148 'any': fn any<f16>() -> f16
145..150 'any()': f16
151..153 '{}': ()
158..180 'if let...y() {}': ()
161..177 'let 1f... any()': bool
165..169 '1f32': f32
165..169 '1f32': f32
172..175 'any': fn any<f32>() -> f32
172..177 'any()': f32
178..180 '{}': ()
185..206 'if let...y() {}': ()
188..203 'let 1.0 = any()': bool
192..195 '1.0': f64
192..195 '1.0': f64
198..201 'any': fn any<f64>() -> f64
198..203 'any()': f64
204..206 '{}': ()
211..234 'if let...y() {}': ()
214..231 'let 1f... any()': bool
218..223 '1f128': f128
218..223 '1f128': f128
226..229 'any': fn any<f128>() -> f128
226..231 'any()': f128
232..234 '{}': ()
239..261 'if let...y() {}': ()
242..258 'let tr... any()': bool
246..250 'true': bool
246..250 'true': bool
253..256 'any': fn any<bool>() -> bool
253..258 'any()': bool
259..261 '{}': ()
"#]],
);
}
#[test]
fn infer_range_pattern() {
check_infer_with_mismatches(
r#"
//- minicore: range
fn test(x..y: &core::ops::Range<u32>) {
if let 1..76 = 2u32 {}
if let 1..=76 = 2u32 {}
}
"#,
expect![[r#"
8..9 'x': Range<u32>
8..12 'x..y': Range<u32>
11..12 'y': Range<u32>
38..96 '{ ...2 {} }': ()
44..66 'if let...u32 {}': ()
47..63 'let 1....= 2u32': bool
51..52 '1': u32
51..56 '1..76': u32
54..56 '76': u32
59..63 '2u32': u32
64..66 '{}': ()
71..94 'if let...u32 {}': ()
74..91 'let 1....= 2u32': bool
78..79 '1': u32
78..84 '1..=76': u32
82..84 '76': u32
87..91 '2u32': u32
92..94 '{}': ()
"#]],
);
check_no_mismatches(
r#"
//- minicore: range
fn main() {
let byte: u8 = 0u8;
let b = match byte {
b'0'..=b'9' => true,
_ => false,
};
}
"#,
);
}
#[test]
fn infer_pattern_match_ergonomics() {
check_infer(
r#"
struct A<T>(T);
fn test() {
let A(n) = &A(1);
let A(n) = &mut A(1);
}
"#,
expect![[r#"
27..78 '{ ...(1); }': ()
37..41 'A(n)': A<i32>
39..40 'n': &'? i32
44..49 '&A(1)': &'? A<i32>
45..46 'A': fn A<i32>(i32) -> A<i32>
45..49 'A(1)': A<i32>
47..48 '1': i32
59..63 'A(n)': A<i32>
61..62 'n': &'? mut i32
66..75 '&mut A(1)': &'? mut A<i32>
71..72 'A': fn A<i32>(i32) -> A<i32>
71..75 'A(1)': A<i32>
73..74 '1': i32
"#]],
);
}
#[test]
fn infer_pattern_match_ergonomics_ref() {
cov_mark::check!(match_ergonomics_ref);
check_infer(
r#"
fn test() {
let v = &(1, &2);
let (_, &w) = v;
}
"#,
expect![[r#"
10..56 '{ ...= v; }': ()
20..21 'v': &'? (i32, &'? i32)
24..32 '&(1, &2)': &'? (i32, &'? i32)
25..32 '(1, &2)': (i32, &'? i32)
26..27 '1': i32
29..31 '&2': &'? i32
30..31 '2': i32
42..49 '(_, &w)': (i32, &'? i32)
43..44 '_': i32
46..48 '&w': &'? i32
47..48 'w': i32
52..53 'v': &'? (i32, &'? i32)
"#]],
);
}
#[test]
fn ref_pat_with_inference_variable() {
check_no_mismatches(
r#"
enum E { A }
fn test() {
let f = |e| match e {
&E::A => {}
};
f(&E::A);
}
"#,
);
}
#[test]
fn infer_pattern_match_slice() {
check_infer(
r#"
fn test() {
let slice: &[f64] = &[0.0];
match slice {
&[] => {},
&[a] => {
a;
},
&[b, c] => {
b;
c;
}
_ => {}
}
}
"#,
expect![[r#"
10..209 '{ ... } }': ()
20..25 'slice': &'? [f64]
36..42 '&[0.0]': &'? [f64; 1]
37..42 '[0.0]': [f64; 1]
38..41 '0.0': f64
48..207 'match ... }': ()
54..59 'slice': &'? [f64]
70..73 '&[]': &'? [f64]
71..73 '[]': [f64]
77..79 '{}': ()
89..93 '&[a]': &'? [f64]
90..93 '[a]': [f64]
91..92 'a': f64
97..123 '{ ... }': ()
111..112 'a': f64
133..140 '&[b, c]': &'? [f64]
134..140 '[b, c]': [f64]
135..136 'b': f64
138..139 'c': f64
144..185 '{ ... }': ()
158..159 'b': f64
173..174 'c': f64
194..195 '_': &'? [f64]
199..201 '{}': ()
"#]],
);
}
#[test]
fn infer_pattern_match_string_literal() {
check_infer_with_mismatches(
r#"
fn test() {
let s: &str = "hello";
match s {
"hello" => {}
_ => {}
}
}
"#,
expect![[r#"
10..98 '{ ... } }': ()
20..21 's': &'? str
30..37 '"hello"': &'static str
43..96 'match ... }': ()
49..50 's': &'? str
61..68 '"hello"': &'static str
61..68 '"hello"': &'static str
72..74 '{}': ()
83..84 '_': &'? str
88..90 '{}': ()
"#]],
);
}
#[test]
fn infer_pattern_match_byte_string_literal() {
check_infer_with_mismatches(
r#"
//- minicore: index, range
struct S;
impl<T, const N: usize> core::ops::Index<S> for [T; N] {
type Output = [u8];
fn index(&self, index: core::ops::RangeFull) -> &Self::Output {
loop {}
}
}
fn test(v: [u8; 3]) {
if let b"foo" = &v[S] {}
if let b"foo" = &v {}
}
"#,
expect![[r#"
105..109 'self': &'? [T; N]
111..116 'index': RangeFull
157..180 '{ ... }': &'? [u8]
167..174 'loop {}': !
172..174 '{}': ()
191..192 'v': [u8; 3]
203..261 '{ ...v {} }': ()
209..233 'if let...[S] {}': ()
212..230 'let b"... &v[S]': bool
216..222 'b"foo"': &'static [u8]
216..222 'b"foo"': &'static [u8]
225..230 '&v[S]': &'? [u8]
226..227 'v': [u8; 3]
226..230 'v[S]': [u8]
228..229 'S': S
231..233 '{}': ()
238..259 'if let... &v {}': ()
241..256 'let b"foo" = &v': bool
245..251 'b"foo"': &'static [u8; 3]
245..251 'b"foo"': &'static [u8; 3]
254..256 '&v': &'? [u8; 3]
255..256 'v': [u8; 3]
257..259 '{}': ()
"#]],
);
}
#[test]
fn infer_pattern_match_or() {
check_infer_with_mismatches(
r#"
fn test() {
let s: &str = "hello";
match s {
"hello" | "world" => {}
_ => {}
}
}
"#,
expect![[r#"
10..108 '{ ... } }': ()
20..21 's': &'? str
30..37 '"hello"': &'static str
43..106 'match ... }': ()
49..50 's': &'? str
61..68 '"hello"': &'static str
61..68 '"hello"': &'static str
61..78 '"hello...world"': &'? str
71..78 '"world"': &'static str
71..78 '"world"': &'static str
82..84 '{}': ()
93..94 '_': &'? str
98..100 '{}': ()
"#]],
);
}
#[test]
fn infer_pattern_match_arr() {
check_infer(
r#"
fn test() {
let arr: [f64; 2] = [0.0, 1.0];
match arr {
[1.0, a] => {
a;
},
[b, c] => {
b;
c;
}
}
}
"#,
expect![[r#"
10..179 '{ ... } }': ()
20..23 'arr': [f64; 2]
36..46 '[0.0, 1.0]': [f64; 2]
37..40 '0.0': f64
42..45 '1.0': f64
52..177 'match ... }': ()
58..61 'arr': [f64; 2]
72..80 '[1.0, a]': [f64; 2]
73..76 '1.0': f64
73..76 '1.0': f64
78..79 'a': f64
84..110 '{ ... }': ()
98..99 'a': f64
120..126 '[b, c]': [f64; 2]
121..122 'b': f64
124..125 'c': f64
130..171 '{ ... }': ()
144..145 'b': f64
159..160 'c': f64
"#]],
);
}
#[test]
fn infer_adt_pattern() {
check_infer(
r#"
enum E {
A { x: usize },
B
}
struct S(u32, E);
fn test() {
let e = E::A { x: 3 };
let S(y, z) = foo;
let E::A { x: new_var } = e;
match e {
E::A { x } => x,
E::B if foo => 1,
E::B => 10,
};
let ref d @ E::A { .. } = e;
d;
}
"#,
expect![[r#"
67..288 '{ ... d; }': ()
77..78 'e': E
81..94 'E::A { x: 3 }': E
91..92 '3': usize
105..112 'S(y, z)': S
107..108 'y': u32
110..111 'z': E
115..118 'foo': S
128..147 'E::A {..._var }': E
138..145 'new_var': usize
150..151 'e': E
158..244 'match ... }': usize
164..165 'e': E
176..186 'E::A { x }': E
183..184 'x': usize
190..191 'x': usize
201..205 'E::B': E
209..212 'foo': bool
216..217 '1': usize
227..231 'E::B': E
235..237 '10': usize
255..274 'ref d ...{ .. }': &'? E
263..274 'E::A { .. }': E
277..278 'e': E
284..285 'd': &'? E
"#]],
);
}
#[test]
fn tuple_struct_destructured_with_self() {
check_infer(
r#"
struct Foo(usize,);
impl Foo {
fn f() {
let Self(s,) = &Foo(0,);
let Self(s,) = &mut Foo(0,);
let Self(s,) = Foo(0,);
}
}
"#,
expect![[r#"
42..151 '{ ... }': ()
56..64 'Self(s,)': Foo
61..62 's': &'? usize
67..75 '&Foo(0,)': &'? Foo
68..71 'Foo': fn Foo(usize) -> Foo
68..75 'Foo(0,)': Foo
72..73 '0': usize
89..97 'Self(s,)': Foo
94..95 's': &'? mut usize
100..112 '&mut Foo(0,)': &'? mut Foo
105..108 'Foo': fn Foo(usize) -> Foo
105..112 'Foo(0,)': Foo
109..110 '0': usize
126..134 'Self(s,)': Foo
131..132 's': usize
137..140 'Foo': fn Foo(usize) -> Foo
137..144 'Foo(0,)': Foo
141..142 '0': usize
"#]],
);
}
#[test]
fn enum_variant_through_self_in_pattern() {
check_infer(
r#"
enum E {
A { x: usize },
B(usize),
C
}
impl E {
fn test() {
match (loop {}) {
Self::A { x } => { x; },
Self::B(x) => { x; },
Self::C => {},
};
}
}
"#,
expect![[r#"
75..217 '{ ... }': ()
85..210 'match ... }': ()
92..99 'loop {}': !
97..99 '{}': ()
115..128 'Self::A { x }': E
125..126 'x': usize
132..138 '{ x; }': ()
134..135 'x': usize
152..162 'Self::B(x)': E
160..161 'x': usize
166..172 '{ x; }': ()
168..169 'x': usize
186..193 'Self::C': E
197..199 '{}': ()
"#]],
);
}
#[test]
fn infer_generics_in_patterns() {
check_infer(
r#"
struct A<T> {
x: T,
}
enum Option<T> {
Some(T),
None,
}
fn test(a1: A<u32>, o: Option<u64>) {
let A { x: x2 } = a1;
let A::<i64> { x: x3 } = A { x: 1 };
match o {
Option::Some(t) => t,
_ => 1,
};
}
"#,
expect![[r#"
78..80 'a1': A<u32>
90..91 'o': Option<u64>
106..243 '{ ... }; }': ()
116..127 'A { x: x2 }': A<u32>
123..125 'x2': u32
130..132 'a1': A<u32>
142..160 'A::<i6...: x3 }': A<i64>
156..158 'x3': i64
163..173 'A { x: 1 }': A<i64>
170..171 '1': i64
179..240 'match ... }': u64
185..186 'o': Option<u64>
197..212 'Option::Some(t)': Option<u64>
210..211 't': u64
216..217 't': u64
227..228 '_': Option<u64>
232..233 '1': u64
"#]],
);
}
#[test]
fn infer_const_pattern() {
check(
r#"
enum Option<T> { None, Some(T) }
use Option::None;
struct Foo;
const Bar: usize = 1;
fn test() {
let a: Option<u32> = None;
let b: Option<i64> = match a {
None => None,
};
let _: () = match () { Foo => () };
// ^^^ expected (), got Foo
let _: () = match () { Bar => () };
// ^^^ expected (), got usize
}
"#,
);
}
#[test]
fn infer_guard() {
check_infer(
r#"
struct S;
impl S { fn foo(&self) -> bool { false } }
fn main() {
match S {
s if s.foo() => (),
}
}
"#,
expect![[r#"
27..31 'self': &'? S
41..50 '{ false }': bool
43..48 'false': bool
64..115 '{ ... } }': ()
70..113 'match ... }': ()
76..77 'S': S
88..89 's': S
93..94 's': S
93..100 's.foo()': bool
104..106 '()': ()
"#]],
)
}
#[test]
fn match_ergonomics_in_closure_params() {
check_infer(
r#"
//- minicore: fn
fn foo<T, U, F: FnOnce(T) -> U>(t: T, f: F) -> U { loop {} }
fn test() {
foo(&(1, "a"), |&(x, y)| x); // normal, no match ergonomics
foo(&(1, "a"), |(x, y)| x);
}
"#,
expect![[r#"
32..33 't': T
38..39 'f': F
49..60 '{ loop {} }': U
51..58 'loop {}': !
56..58 '{}': ()
72..171 '{ ... x); }': ()
78..81 'foo': fn foo<&'? (i32, &'? str), i32, impl FnOnce(&'? (i32, &'? str)) -> i32>(&'? (i32, &'? str), impl FnOnce(&'? (i32, &'? str)) -> i32) -> i32
78..105 'foo(&(...y)| x)': i32
82..91 '&(1, "a")': &'? (i32, &'? str)
83..91 '(1, "a")': (i32, &'? str)
84..85 '1': i32
87..90 '"a"': &'static str
93..104 '|&(x, y)| x': impl FnOnce(&'? (i32, &'? str)) -> i32
94..101 '&(x, y)': &'? (i32, &'? str)
95..101 '(x, y)': (i32, &'? str)
96..97 'x': i32
99..100 'y': &'? str
103..104 'x': i32
142..145 'foo': fn foo<&'? (i32, &'? str), &'? i32, impl FnOnce(&'? (i32, &'? str)) -> &'? i32>(&'? (i32, &'? str), impl FnOnce(&'? (i32, &'? str)) -> &'? i32) -> &'? i32
142..168 'foo(&(...y)| x)': &'? i32
146..155 '&(1, "a")': &'? (i32, &'? str)
147..155 '(1, "a")': (i32, &'? str)
148..149 '1': i32
151..154 '"a"': &'static str
157..167 '|(x, y)| x': impl FnOnce(&'? (i32, &'? str)) -> &'? i32
158..164 '(x, y)': (i32, &'? str)
159..160 'x': &'? i32
162..163 'y': &'? &'? str
166..167 'x': &'? i32
"#]],
);
}
#[test]
fn slice_tail_pattern() {
check_infer(
r#"
fn foo(params: &[i32]) {
match params {
[head, tail @ ..] => {
}
}
}
"#,
expect![[r#"
7..13 'params': &'? [i32]
23..92 '{ ... } }': ()
29..90 'match ... }': ()
35..41 'params': &'? [i32]
52..69 '[head,... @ ..]': [i32]
53..57 'head': &'? i32
59..68 'tail @ ..': &'? [i32]
66..68 '..': [i32]
73..84 '{ }': ()
"#]],
);
}
#[test]
fn box_pattern() {
check_infer(
r#"
#![feature(lang_items)]
pub struct Global;
#[lang = "owned_box"]
pub struct Box<T, A = Global>(T);
fn foo(params: Box<i32>) {
match params {
box integer => {}
}
}
"#,
expect![[r#"
108..114 'params': Box<i32, Global>
126..180 '{ ... } }': ()
132..178 'match ... }': ()
138..144 'params': Box<i32, Global>
155..166 'box integer': Box<i32, Global>
159..166 'integer': i32
170..172 '{}': ()
"#]],
);
check_infer(
r#"
#[lang = "owned_box"]
pub struct Box<T>(T);
fn foo(params: Box<i32>) {
match params {
box integer => {}
}
}
"#,
expect![[r#"
52..58 'params': Box<i32>
70..124 '{ ... } }': ()
76..122 'match ... }': ()
82..88 'params': Box<i32>
99..110 'box integer': Box<i32>
114..116 '{}': ()
"#]],
);
}
#[test]
fn tuple_ellipsis_pattern() {
check_infer_with_mismatches(
r#"
fn foo(tuple: (u8, i16, f32)) {
match tuple {
(.., b, c) => {},
(a, .., c) => {},
(a, b, ..) => {},
(a, b) => {/*too short*/}
(a, b, c, d) => {/*too long*/}
_ => {}
}
}"#,
expect![[r#"
7..12 'tuple': (u8, i16, f32)
30..224 '{ ... } }': ()
36..222 'match ... }': ()
42..47 'tuple': (u8, i16, f32)
58..68 '(.., b, c)': (u8, i16, f32)
63..64 'b': i16
66..67 'c': f32
72..74 '{}': ()
84..94 '(a, .., c)': (u8, i16, f32)
85..86 'a': u8
92..93 'c': f32
98..100 '{}': ()
110..120 '(a, b, ..)': (u8, i16, f32)
111..112 'a': u8
114..115 'b': i16
124..126 '{}': ()
136..142 '(a, b)': (u8, i16)
137..138 'a': u8
140..141 'b': i16
146..161 '{/*too short*/}': ()
170..182 '(a, b, c, d)': (u8, i16, f32, {unknown})
171..172 'a': u8
174..175 'b': i16
177..178 'c': f32
180..181 'd': {unknown}
186..200 '{/*too long*/}': ()
209..210 '_': (u8, i16, f32)
214..216 '{}': ()
136..142: expected (u8, i16, f32), got (u8, i16)
170..182: expected (u8, i16, f32), got (u8, i16, f32, {unknown})
"#]],
);
}
#[test]
fn tuple_struct_ellipsis_pattern() {
check_infer(
r#"
struct Tuple(u8, i16, f32);
fn foo(tuple: Tuple) {
match tuple {
Tuple(.., b, c) => {},
Tuple(a, .., c) => {},
Tuple(a, b, ..) => {},
Tuple(a, b) => {/*too short*/}
Tuple(a, b, c, d) => {/*too long*/}
_ => {}
}
}"#,
expect![[r#"
35..40 'tuple': Tuple
49..268 '{ ... } }': ()
55..266 'match ... }': ()
61..66 'tuple': Tuple
77..92 'Tuple(.., b, c)': Tuple
87..88 'b': i16
90..91 'c': f32
96..98 '{}': ()
108..123 'Tuple(a, .., c)': Tuple
114..115 'a': u8
121..122 'c': f32
127..129 '{}': ()
139..154 'Tuple(a, b, ..)': Tuple
145..146 'a': u8
148..149 'b': i16
158..160 '{}': ()
170..181 'Tuple(a, b)': Tuple
176..177 'a': u8
179..180 'b': i16
185..200 '{/*too short*/}': ()
209..226 'Tuple(... c, d)': Tuple
215..216 'a': u8
218..219 'b': i16
221..222 'c': f32
224..225 'd': {unknown}
230..244 '{/*too long*/}': ()
253..254 '_': Tuple
258..260 '{}': ()
"#]],
);
}
#[test]
fn const_block_pattern() {
check_infer(
r#"
struct Foo(usize);
fn foo(foo: Foo) {
match foo {
const { Foo(15 + 32) } => {},
_ => {}
}
}"#,
expect![[r#"
26..29 'foo': Foo
36..115 '{ ... } }': ()
42..113 'match ... }': ()
48..51 'foo': Foo
62..84 'const ... 32) }': Foo
68..84 '{ Foo(... 32) }': Foo
70..73 'Foo': fn Foo(usize) -> Foo
70..82 'Foo(15 + 32)': Foo
74..76 '15': usize
74..81 '15 + 32': usize
79..81 '32': usize
88..90 '{}': ()
100..101 '_': Foo
105..107 '{}': ()
"#]],
);
}
#[test]
fn macro_pat() {
check_types(
r#"
macro_rules! pat {
($name:ident) => { Enum::Variant1($name) }
}
enum Enum {
Variant1(u8),
Variant2,
}
fn f(e: Enum) {
match e {
pat!(bind) => {
bind;
//^^^^ u8
}
Enum::Variant2 => {}
}
}
"#,
)
}
#[test]
fn type_mismatch_in_or_pattern() {
check_infer_with_mismatches(
r#"
fn main() {
match (false,) {
(true | (),) => {}
(() | true,) => {}
(_ | (),) => {}
(() | _,) => {}
}
}
"#,
expect![[r#"
10..142 '{ ... } }': ()
16..140 'match ... }': ()
22..30 '(false,)': (bool,)
23..28 'false': bool
41..53 '(true | (),)': (bool,)
42..46 'true': bool
42..46 'true': bool
42..51 'true | ()': bool
49..51 '()': ()
57..59 '{}': ()
68..80 '(() | true,)': (bool,)
69..71 '()': ()
69..78 '() | true': bool
74..78 'true': bool
74..78 'true': bool
84..86 '{}': ()
95..104 '(_ | (),)': (bool,)
96..97 '_': bool
96..102 '_ | ()': bool
100..102 '()': ()
108..110 '{}': ()
119..128 '(() | _,)': (bool,)
120..122 '()': ()
120..126 '() | _': bool
125..126 '_': bool
132..134 '{}': ()
49..51: expected bool, got ()
69..71: expected bool, got ()
100..102: expected bool, got ()
120..122: expected bool, got ()
"#]],
);
}
#[test]
fn slice_pattern_correctly_handles_array_length() {
check_infer(
r#"
fn main() {
let [head, middle @ .., tail, tail2] = [1, 2, 3, 4, 5];
}
"#,
expect![[r#"
10..73 '{ ... 5]; }': ()
20..52 '[head,...tail2]': [i32; 5]
21..25 'head': i32
27..38 'middle @ ..': [i32; 2]
36..38 '..': [i32; 2]
40..44 'tail': i32
46..51 'tail2': i32
55..70 '[1, 2, 3, 4, 5]': [i32; 5]
56..57 '1': i32
59..60 '2': i32
62..63 '3': i32
65..66 '4': i32
68..69 '5': i32
"#]],
);
}
#[test]
fn pattern_lookup_in_value_ns() {
check_types(
r#"
use self::Constructor::*;
struct IntRange {
range: (),
}
enum Constructor {
IntRange(IntRange),
}
fn main() {
match Constructor::IntRange(IntRange { range: () }) {
IntRange(x) => {
x;
//^ IntRange
}
Constructor::IntRange(x) => {
x;
//^ IntRange
}
}
}
"#,
);
}
#[test]
fn if_let_guards() {
check_types(
r#"
fn main() {
match (0,) {
opt if let (x,) = opt => {
x;
//^ i32
}
_ => {}
}
}
"#,
);
}
#[test]
fn tuple_wildcard() {
check_types(
r#"
fn main() {
enum Option<T> {Some(T), None}
use Option::*;
let mut x = None;
x;
//^ Option<(i32, i32)>
if let Some((_, _a)) = x {}
x = Some((1, 2));
}
"#,
);
}
#[test]
fn cfg_params() {
check_types(
r#"
fn my_fn(#[cfg(feature = "feature")] u8: u8, u32: u32) {}
//^^^ u32
"#,
);
}
#[test]
fn var_args() {
check_types(
r#"
#![feature(lang_items)]
#[lang = "va_list"]
pub struct VaListImpl<'f>;
fn my_fn(foo: ...) {}
//^^^ VaListImpl<'?>
fn my_fn2(bar: u32, foo: ...) {}
//^^^ VaListImpl<'?>
"#,
);
}
#[test]
fn var_args_cond() {
check_types(
r#"
#![feature(lang_items)]
#[lang = "va_list"]
pub struct VaListImpl<'f>;
fn my_fn(bar: u32, #[cfg(FALSE)] foo: ..., #[cfg(not(FALSE))] foo: u32) {
foo;
//^^^ u32
}
"#,
);
}
#[test]
fn ref_pat_mutability() {
check(
r#"
fn foo() {
let &() = &();
let &mut () = &mut ();
let &mut () = &();
//^^^^^^^ expected &'? (), got &'? mut ()
let &() = &mut ();
//^^^ expected &'? mut (), got &'? ()
}
"#,
);
}
#[test]
fn generic_alias() {
check_types(
r#"
type Wrap<T> = T;
enum X {
A { cool: u32, stuff: u32 },
B,
}
fn main() {
let wrapped = Wrap::<X>::A {
cool: 100,
stuff: 100,
};
if let Wrap::<X>::A { cool, ..} = &wrapped {}
//^^^^ &'? u32
}
"#,
);
}
#[test]
fn generic_alias_with_qualified_path() {
check_types(
r#"
type Wrap<T> = T;
struct S;
trait Schematic {
type Props;
}
impl Schematic for S {
type Props = X;
}
enum X {
A { cool: u32, stuff: u32 },
B,
}
fn main() {
let wrapped = Wrap::<<S as Schematic>::Props>::A {
cool: 100,
stuff: 100,
};
if let Wrap::<<S as Schematic>::Props>::A { cool, ..} = &wrapped {}
//^^^^ &'? u32
}
"#,
);
}
#[test]
fn type_mismatch_pat_const_reference() {
check_no_mismatches(
r#"
const TEST_STR: &'static str = "abcd";
fn main() {
let s = "abcd";
match s {
TEST_STR => (),
_ => (),
}
}
"#,
);
check(
r#"
struct Foo<T>(T);
impl<T> Foo<T> {
const TEST_I32_REF: &'static i32 = &3;
const TEST_I32: i32 = 3;
}
fn main() {
match &6 {
Foo::<i32>::TEST_I32_REF => (),
Foo::<i32>::TEST_I32 => (),
//^^^^^^^^^^^^^^^^^^^^ expected &'? i32, got i32
_ => (),
}
}
"#,
);
}
#[test]
fn destructuring_assign_ref() {
check_no_mismatches(
r#"
struct Foo;
fn foo() -> (&'static Foo, u32) {
(&Foo, 0)
}
fn bar() {
let ext: &Foo;
let v;
(ext, v) = foo();
}
"#,
);
}