diff options
Diffstat (limited to 'crates/ra_hir/src/ty/tests.rs')
-rw-r--r-- | crates/ra_hir/src/ty/tests.rs | 161 |
1 files changed, 40 insertions, 121 deletions
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs index 2ce0039b1..081bfe37c 100644 --- a/crates/ra_hir/src/ty/tests.rs +++ b/crates/ra_hir/src/ty/tests.rs | |||
@@ -20,6 +20,8 @@ use crate::{ | |||
20 | // against snapshots of the expected results using insta. Use cargo-insta to | 20 | // against snapshots of the expected results using insta. Use cargo-insta to |
21 | // update the snapshots. | 21 | // update the snapshots. |
22 | 22 | ||
23 | mod never_type; | ||
24 | |||
23 | #[test] | 25 | #[test] |
24 | fn infer_await() { | 26 | fn infer_await() { |
25 | let (mut db, pos) = MockDatabase::with_position( | 27 | let (mut db, pos) = MockDatabase::with_position( |
@@ -1078,6 +1080,42 @@ fn test(i: i32) { | |||
1078 | } | 1080 | } |
1079 | 1081 | ||
1080 | #[test] | 1082 | #[test] |
1083 | fn coerce_merge_one_by_one1() { | ||
1084 | covers!(coerce_merge_fail_fallback); | ||
1085 | |||
1086 | assert_snapshot!( | ||
1087 | infer(r#" | ||
1088 | fn test() { | ||
1089 | let t = &mut 1; | ||
1090 | let x = match 1 { | ||
1091 | 1 => t as *mut i32, | ||
1092 | 2 => t as &i32, | ||
1093 | _ => t as *const i32, | ||
1094 | }; | ||
1095 | } | ||
1096 | "#), | ||
1097 | @r###" | ||
1098 | [11; 145) '{ ... }; }': () | ||
1099 | [21; 22) 't': &mut i32 | ||
1100 | [25; 31) '&mut 1': &mut i32 | ||
1101 | [30; 31) '1': i32 | ||
1102 | [41; 42) 'x': *const i32 | ||
1103 | [45; 142) 'match ... }': *const i32 | ||
1104 | [51; 52) '1': i32 | ||
1105 | [63; 64) '1': i32 | ||
1106 | [68; 69) 't': &mut i32 | ||
1107 | [68; 81) 't as *mut i32': *mut i32 | ||
1108 | [91; 92) '2': i32 | ||
1109 | [96; 97) 't': &mut i32 | ||
1110 | [96; 105) 't as &i32': &i32 | ||
1111 | [115; 116) '_': i32 | ||
1112 | [120; 121) 't': &mut i32 | ||
1113 | [120; 135) 't as *const i32': *const i32 | ||
1114 | "### | ||
1115 | ); | ||
1116 | } | ||
1117 | |||
1118 | #[test] | ||
1081 | fn bug_484() { | 1119 | fn bug_484() { |
1082 | assert_snapshot!( | 1120 | assert_snapshot!( |
1083 | infer(r#" | 1121 | infer(r#" |
@@ -2458,7 +2496,6 @@ fn extra_compiler_flags() { | |||
2458 | } | 2496 | } |
2459 | "#), | 2497 | "#), |
2460 | @r###" | 2498 | @r###" |
2461 | |||
2462 | [27; 323) '{ ... } }': () | 2499 | [27; 323) '{ ... } }': () |
2463 | [33; 321) 'for co... }': () | 2500 | [33; 321) 'for co... }': () |
2464 | [37; 44) 'content': &{unknown} | 2501 | [37; 44) 'content': &{unknown} |
@@ -2472,8 +2509,8 @@ fn extra_compiler_flags() { | |||
2472 | [135; 167) '{ ... }': &&{unknown} | 2509 | [135; 167) '{ ... }': &&{unknown} |
2473 | [149; 157) '&content': &&{unknown} | 2510 | [149; 157) '&content': &&{unknown} |
2474 | [150; 157) 'content': &{unknown} | 2511 | [150; 157) 'content': &{unknown} |
2475 | [182; 189) 'content': &&{unknown} | 2512 | [182; 189) 'content': &{unknown} |
2476 | [192; 314) 'if ICE... }': &&{unknown} | 2513 | [192; 314) 'if ICE... }': &{unknown} |
2477 | [195; 232) 'ICE_RE..._VALUE': {unknown} | 2514 | [195; 232) 'ICE_RE..._VALUE': {unknown} |
2478 | [195; 248) 'ICE_RE...&name)': bool | 2515 | [195; 248) 'ICE_RE...&name)': bool |
2479 | [242; 247) '&name': &&&{unknown} | 2516 | [242; 247) '&name': &&&{unknown} |
@@ -4683,121 +4720,3 @@ fn no_such_field_diagnostics() { | |||
4683 | "### | 4720 | "### |
4684 | ); | 4721 | ); |
4685 | } | 4722 | } |
4686 | |||
4687 | mod branching_with_never_tests { | ||
4688 | use super::type_at; | ||
4689 | |||
4690 | #[test] | ||
4691 | fn if_never() { | ||
4692 | let t = type_at( | ||
4693 | r#" | ||
4694 | //- /main.rs | ||
4695 | fn test() { | ||
4696 | let i = if true { | ||
4697 | loop {} | ||
4698 | } else { | ||
4699 | 3.0 | ||
4700 | }; | ||
4701 | i<|> | ||
4702 | () | ||
4703 | } | ||
4704 | "#, | ||
4705 | ); | ||
4706 | assert_eq!(t, "f64"); | ||
4707 | } | ||
4708 | |||
4709 | #[test] | ||
4710 | fn if_else_never() { | ||
4711 | let t = type_at( | ||
4712 | r#" | ||
4713 | //- /main.rs | ||
4714 | fn test(input: bool) { | ||
4715 | let i = if input { | ||
4716 | 2.0 | ||
4717 | } else { | ||
4718 | return | ||
4719 | }; | ||
4720 | i<|> | ||
4721 | () | ||
4722 | } | ||
4723 | "#, | ||
4724 | ); | ||
4725 | assert_eq!(t, "f64"); | ||
4726 | } | ||
4727 | |||
4728 | #[test] | ||
4729 | fn match_first_arm_never() { | ||
4730 | let t = type_at( | ||
4731 | r#" | ||
4732 | //- /main.rs | ||
4733 | fn test(a: i32) { | ||
4734 | let i = match a { | ||
4735 | 1 => return, | ||
4736 | 2 => 2.0, | ||
4737 | 3 => loop {}, | ||
4738 | _ => 3.0, | ||
4739 | }; | ||
4740 | i<|> | ||
4741 | () | ||
4742 | } | ||
4743 | "#, | ||
4744 | ); | ||
4745 | assert_eq!(t, "f64"); | ||
4746 | } | ||
4747 | |||
4748 | #[test] | ||
4749 | fn match_second_arm_never() { | ||
4750 | let t = type_at( | ||
4751 | r#" | ||
4752 | //- /main.rs | ||
4753 | fn test(a: i32) { | ||
4754 | let i = match a { | ||
4755 | 1 => 3.0, | ||
4756 | 2 => loop {}, | ||
4757 | 3 => 3.0, | ||
4758 | _ => return, | ||
4759 | }; | ||
4760 | i<|> | ||
4761 | () | ||
4762 | } | ||
4763 | "#, | ||
4764 | ); | ||
4765 | assert_eq!(t, "f64"); | ||
4766 | } | ||
4767 | |||
4768 | #[test] | ||
4769 | fn match_all_arms_never() { | ||
4770 | let t = type_at( | ||
4771 | r#" | ||
4772 | //- /main.rs | ||
4773 | fn test(a: i32) { | ||
4774 | let i = match a { | ||
4775 | 2 => return, | ||
4776 | _ => loop {}, | ||
4777 | }; | ||
4778 | i<|> | ||
4779 | () | ||
4780 | } | ||
4781 | "#, | ||
4782 | ); | ||
4783 | assert_eq!(t, "!"); | ||
4784 | } | ||
4785 | |||
4786 | #[test] | ||
4787 | fn match_no_never_arms() { | ||
4788 | let t = type_at( | ||
4789 | r#" | ||
4790 | //- /main.rs | ||
4791 | fn test(a: i32) { | ||
4792 | let i = match a { | ||
4793 | 2 => 2.0, | ||
4794 | _ => 3.0, | ||
4795 | }; | ||
4796 | i<|> | ||
4797 | () | ||
4798 | } | ||
4799 | "#, | ||
4800 | ); | ||
4801 | assert_eq!(t, "f64"); | ||
4802 | } | ||
4803 | } | ||