1 use expect_test::expect;
3 use super::{check_infer_with_mismatches, check_types};
21 fn gen<T>() -> T { loop {} }
25 if false { a } else { loop {} };
36 fn gen<T>() -> T { loop {} }
40 if false { loop {} } else { a };
49 fn never_type_in_generic_args() {
52 enum Option<T> { None, Some(T) }
55 let a = if true { Option::None } else { Option::Some(return) };
63 fn never_type_can_be_reinferred1() {
66 fn gen<T>() -> T { loop {} }
70 if false { loop {} } else { a };
80 fn never_type_can_be_reinferred2() {
83 enum Option<T> { None, Some(T) }
86 let a = if true { Option::None } else { Option::Some(return) };
91 _ => Option::Some(42),
99 fn never_type_can_be_reinferred3() {
102 enum Option<T> { None, Some(T) }
105 let a = if true { Option::None } else { Option::Some(return) };
110 _ => Option::Some("str"),
132 fn match_unknown_arm() {
165 fn test(input: bool) {
178 fn match_first_arm_never() {
195 fn match_second_arm_never() {
212 fn match_all_arms_never() {
227 fn match_no_never_arms() {
242 fn diverging_expression_1() {
243 check_infer_with_mismatches(
250 let x: u32 = { return; };
253 let x: u32 = loop {};
256 let x: u32 = { loop {} };
259 let x: u32 = { if true { loop {}; } else { loop {}; } };
262 let x: u32 = { let y: u32 = { loop {}; }; };
266 11..39 '{ ...urn; }': ()
269 51..84 '{ ...; }; }': ()
271 70..81 '{ return; }': u32
273 96..125 '{ ... {}; }': ()
275 115..122 'loop {}': !
277 137..170 '{ ...} }; }': ()
279 156..167 '{ loop {} }': u32
280 158..165 'loop {}': !
282 182..246 '{ ...} }; }': ()
284 201..243 '{ if t...}; } }': u32
285 203..241 'if tru... {}; }': u32
286 206..210 'true': bool
287 211..223 '{ loop {}; }': u32
288 213..220 'loop {}': !
290 229..241 '{ loop {}; }': u32
291 231..238 'loop {}': !
293 258..310 '{ ...; }; }': ()
295 277..307 '{ let ...; }; }': u32
297 292..304 '{ loop {}; }': u32
298 294..301 'loop {}': !
305 fn diverging_expression_2() {
306 check_infer_with_mismatches(
310 // should give type mismatch
311 let x: u32 = { loop {}; "foo" };
315 11..84 '{ ..." }; }': ()
317 63..81 '{ loop...foo" }': &str
321 63..81: expected u32, got &str
322 74..79: expected u32, got &str
328 fn diverging_expression_3_break() {
329 check_infer_with_mismatches(
333 // should give type mismatch
334 let x: u32 = { loop { break; } };
337 // should give type mismatch
338 let x: u32 = { for a in b { break; }; };
339 // should give type mismatch as well
340 let x: u32 = { for a in b {}; };
341 // should give type mismatch as well
342 let x: u32 = { for a in b { return; }; };
345 // should give type mismatch
346 let x: u32 = { while true { break; }; };
347 // should give type mismatch as well -- there's an implicit break, even if it's never hit
348 let x: u32 = { while true {}; };
349 // should give type mismatch as well
350 let x: u32 = { while true { return; }; };
354 11..85 '{ ...} }; }': ()
356 63..82 '{ loop...k; } }': ()
357 65..80 'loop { break; }': ()
358 70..80 '{ break; }': ()
360 63..82: expected u32, got ()
361 65..80: expected u32, got ()
362 97..343 '{ ...; }; }': ()
364 149..175 '{ for ...; }; }': ()
365 151..172 'for a ...eak; }': ()
366 155..156 'a': {unknown}
367 160..161 'b': {unknown}
368 162..172 '{ break; }': ()
371 235..253 '{ for ... {}; }': ()
372 237..250 'for a in b {}': ()
373 241..242 'a': {unknown}
374 246..247 'b': {unknown}
377 313..340 '{ for ...; }; }': ()
378 315..337 'for a ...urn; }': ()
379 319..320 'a': {unknown}
380 324..325 'b': {unknown}
381 326..337 '{ return; }': ()
383 149..175: expected u32, got ()
384 235..253: expected u32, got ()
385 313..340: expected u32, got ()
386 355..654 '{ ...; }; }': ()
388 407..433 '{ whil...; }; }': ()
389 409..430 'while ...eak; }': ()
390 415..419 'true': bool
391 420..430 '{ break; }': ()
394 546..564 '{ whil... {}; }': ()
395 548..561 'while true {}': ()
396 554..558 'true': bool
399 624..651 '{ whil...; }; }': ()
400 626..648 'while ...urn; }': ()
401 632..636 'true': bool
402 637..648 '{ return; }': ()
404 407..433: expected u32, got ()
405 546..564: expected u32, got ()
406 624..651: expected u32, got ()