diff options
Diffstat (limited to 'crates/ra_hir_ty/src/tests/coercion.rs')
-rw-r--r-- | crates/ra_hir_ty/src/tests/coercion.rs | 159 |
1 files changed, 159 insertions, 0 deletions
diff --git a/crates/ra_hir_ty/src/tests/coercion.rs b/crates/ra_hir_ty/src/tests/coercion.rs index 1530fcc63..7e99a42ed 100644 --- a/crates/ra_hir_ty/src/tests/coercion.rs +++ b/crates/ra_hir_ty/src/tests/coercion.rs | |||
@@ -1,3 +1,4 @@ | |||
1 | use super::infer_with_mismatches; | ||
1 | use insta::assert_snapshot; | 2 | use insta::assert_snapshot; |
2 | use test_utils::covers; | 3 | use test_utils::covers; |
3 | 4 | ||
@@ -367,3 +368,161 @@ fn test() { | |||
367 | "### | 368 | "### |
368 | ); | 369 | ); |
369 | } | 370 | } |
371 | |||
372 | #[test] | ||
373 | fn return_coerce_unknown() { | ||
374 | assert_snapshot!( | ||
375 | infer_with_mismatches(r#" | ||
376 | fn foo() -> u32 { | ||
377 | return unknown; | ||
378 | } | ||
379 | "#, true), | ||
380 | @r###" | ||
381 | [17; 40) '{ ...own; }': ! | ||
382 | [23; 37) 'return unknown': ! | ||
383 | [30; 37) 'unknown': u32 | ||
384 | "### | ||
385 | ); | ||
386 | } | ||
387 | |||
388 | #[test] | ||
389 | fn coerce_autoderef() { | ||
390 | assert_snapshot!( | ||
391 | infer_with_mismatches(r#" | ||
392 | struct Foo; | ||
393 | fn takes_ref_foo(x: &Foo) {} | ||
394 | fn test() { | ||
395 | takes_ref_foo(&Foo); | ||
396 | takes_ref_foo(&&Foo); | ||
397 | takes_ref_foo(&&&Foo); | ||
398 | } | ||
399 | "#, true), | ||
400 | @r###" | ||
401 | [30; 31) 'x': &Foo | ||
402 | [39; 41) '{}': () | ||
403 | [52; 133) '{ ...oo); }': () | ||
404 | [58; 71) 'takes_ref_foo': fn takes_ref_foo(&Foo) -> () | ||
405 | [58; 77) 'takes_...(&Foo)': () | ||
406 | [72; 76) '&Foo': &Foo | ||
407 | [73; 76) 'Foo': Foo | ||
408 | [83; 96) 'takes_ref_foo': fn takes_ref_foo(&Foo) -> () | ||
409 | [83; 103) 'takes_...&&Foo)': () | ||
410 | [97; 102) '&&Foo': &&Foo | ||
411 | [98; 102) '&Foo': &Foo | ||
412 | [99; 102) 'Foo': Foo | ||
413 | [109; 122) 'takes_ref_foo': fn takes_ref_foo(&Foo) -> () | ||
414 | [109; 130) 'takes_...&&Foo)': () | ||
415 | [123; 129) '&&&Foo': &&&Foo | ||
416 | [124; 129) '&&Foo': &&Foo | ||
417 | [125; 129) '&Foo': &Foo | ||
418 | [126; 129) 'Foo': Foo | ||
419 | "### | ||
420 | ); | ||
421 | } | ||
422 | |||
423 | #[test] | ||
424 | fn coerce_autoderef_generic() { | ||
425 | assert_snapshot!( | ||
426 | infer_with_mismatches(r#" | ||
427 | struct Foo; | ||
428 | fn takes_ref<T>(x: &T) -> T { *x } | ||
429 | fn test() { | ||
430 | takes_ref(&Foo); | ||
431 | takes_ref(&&Foo); | ||
432 | takes_ref(&&&Foo); | ||
433 | } | ||
434 | "#, true), | ||
435 | @r###" | ||
436 | [29; 30) 'x': &T | ||
437 | [41; 47) '{ *x }': T | ||
438 | [43; 45) '*x': T | ||
439 | [44; 45) 'x': &T | ||
440 | [58; 127) '{ ...oo); }': () | ||
441 | [64; 73) 'takes_ref': fn takes_ref<Foo>(&T) -> T | ||
442 | [64; 79) 'takes_ref(&Foo)': Foo | ||
443 | [74; 78) '&Foo': &Foo | ||
444 | [75; 78) 'Foo': Foo | ||
445 | [85; 94) 'takes_ref': fn takes_ref<&Foo>(&T) -> T | ||
446 | [85; 101) 'takes_...&&Foo)': &Foo | ||
447 | [95; 100) '&&Foo': &&Foo | ||
448 | [96; 100) '&Foo': &Foo | ||
449 | [97; 100) 'Foo': Foo | ||
450 | [107; 116) 'takes_ref': fn takes_ref<&&Foo>(&T) -> T | ||
451 | [107; 124) 'takes_...&&Foo)': &&Foo | ||
452 | [117; 123) '&&&Foo': &&&Foo | ||
453 | [118; 123) '&&Foo': &&Foo | ||
454 | [119; 123) '&Foo': &Foo | ||
455 | [120; 123) 'Foo': Foo | ||
456 | "### | ||
457 | ); | ||
458 | } | ||
459 | |||
460 | #[test] | ||
461 | fn closure_return_coerce() { | ||
462 | assert_snapshot!( | ||
463 | infer_with_mismatches(r#" | ||
464 | fn foo() { | ||
465 | let x = || { | ||
466 | if true { | ||
467 | return &1u32; | ||
468 | } | ||
469 | &&1u32 | ||
470 | }; | ||
471 | } | ||
472 | "#, true), | ||
473 | @r###" | ||
474 | [10; 106) '{ ... }; }': () | ||
475 | [20; 21) 'x': || -> &u32 | ||
476 | [24; 103) '|| { ... }': || -> &u32 | ||
477 | [27; 103) '{ ... }': &u32 | ||
478 | [37; 82) 'if tru... }': () | ||
479 | [40; 44) 'true': bool | ||
480 | [45; 82) '{ ... }': ! | ||
481 | [59; 71) 'return &1u32': ! | ||
482 | [66; 71) '&1u32': &u32 | ||
483 | [67; 71) '1u32': u32 | ||
484 | [91; 97) '&&1u32': &&u32 | ||
485 | [92; 97) '&1u32': &u32 | ||
486 | [93; 97) '1u32': u32 | ||
487 | "### | ||
488 | ); | ||
489 | } | ||
490 | |||
491 | #[test] | ||
492 | fn coerce_fn_item_to_fn_ptr() { | ||
493 | assert_snapshot!( | ||
494 | infer_with_mismatches(r#" | ||
495 | fn foo(x: u32) -> isize { 1 } | ||
496 | fn test() { | ||
497 | let f: fn(u32) -> isize = foo; | ||
498 | } | ||
499 | "#, true), | ||
500 | @r###" | ||
501 | [8; 9) 'x': u32 | ||
502 | [25; 30) '{ 1 }': isize | ||
503 | [27; 28) '1': isize | ||
504 | [41; 79) '{ ...foo; }': () | ||
505 | [51; 52) 'f': fn(u32) -> isize | ||
506 | [73; 76) 'foo': fn foo(u32) -> isize | ||
507 | "### | ||
508 | ); | ||
509 | } | ||
510 | |||
511 | #[test] | ||
512 | fn coerce_closure_to_fn_ptr() { | ||
513 | assert_snapshot!( | ||
514 | infer_with_mismatches(r#" | ||
515 | fn test() { | ||
516 | let f: fn(u32) -> isize = |x| { 1 }; | ||
517 | } | ||
518 | "#, true), | ||
519 | @r###" | ||
520 | [11; 55) '{ ...1 }; }': () | ||
521 | [21; 22) 'f': fn(u32) -> isize | ||
522 | [43; 52) '|x| { 1 }': |u32| -> isize | ||
523 | [44; 45) 'x': u32 | ||
524 | [47; 52) '{ 1 }': isize | ||
525 | [49; 50) '1': isize | ||
526 | "### | ||
527 | ); | ||
528 | } | ||