From 0219b145ea255e215693d0fc324aa78311a41236 Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Sun, 20 Jun 2021 18:36:59 +0200 Subject: Clean up coercion tests --- crates/hir_ty/src/tests/coercion.rs | 669 +++++++----------------------------- 1 file changed, 117 insertions(+), 552 deletions(-) (limited to 'crates/hir_ty') diff --git a/crates/hir_ty/src/tests/coercion.rs b/crates/hir_ty/src/tests/coercion.rs index 24ce5bcca..87089f09d 100644 --- a/crates/hir_ty/src/tests/coercion.rs +++ b/crates/hir_ty/src/tests/coercion.rs @@ -1,27 +1,22 @@ -use expect_test::expect; - -use super::{check_infer, check_infer_with_mismatches, check_no_mismatches, check_types}; +use super::{check, check_no_mismatches, check_types}; #[test] -fn infer_block_expr_type_mismatch() { - check_infer( +fn block_expr_type_mismatch() { + // FIXME fix double type mismatch + check( r" - fn test() { - let a: i32 = { 1i64 }; - } +fn test() { + let a: i32 = { 1i64 }; + // ^^^^^^^^ expected i32, got i64 + // ^^^^ expected i32, got i64 +} ", - expect![[r" - 10..40 '{ ...4 }; }': () - 20..21 'a': i32 - 29..37 '{ 1i64 }': i64 - 31..35 '1i64': i64 - "]], ); } #[test] fn coerce_places() { - check_infer( + check_no_mismatches( r#" //- minicore: coerce_unsized struct S { a: T } @@ -46,81 +41,25 @@ fn test2() { let g: (&[_], &[_]) = (arr, arr); } "#, - expect![[r#" - 30..31 '_': &[T] - 44..55 '{ loop {} }': T - 46..53 'loop {}': ! - 51..53 '{}': () - 64..65 '_': S<&[T]> - 81..92 '{ loop {} }': T - 83..90 'loop {}': ! - 88..90 '{}': () - 121..132 '{ loop {} }': *mut [T; 2] - 123..130 'loop {}': ! - 128..130 '{}': () - 159..172 '{ gen() }': *mut [U] - 165..168 'gen': fn gen() -> *mut [U; 2] - 165..170 'gen()': *mut [U; 2] - 185..419 '{ ...rr); }': () - 195..198 'arr': &[u8; 1] - 211..215 '&[1]': &[u8; 1] - 212..215 '[1]': [u8; 1] - 213..214 '1': u8 - 226..227 'a': &[u8] - 236..239 'arr': &[u8; 1] - 249..250 'b': u8 - 253..254 'f': fn f(&[u8]) -> u8 - 253..259 'f(arr)': u8 - 255..258 'arr': &[u8; 1] - 269..270 'c': &[u8] - 279..286 '{ arr }': &[u8] - 281..284 'arr': &[u8; 1] - 296..297 'd': u8 - 300..301 'g': fn g(S<&[u8]>) -> u8 - 300..315 'g(S { a: arr })': u8 - 302..314 'S { a: arr }': S<&[u8]> - 309..312 'arr': &[u8; 1] - 325..326 'e': [&[u8]; 1] - 340..345 '[arr]': [&[u8]; 1] - 341..344 'arr': &[u8; 1] - 355..356 'f': [&[u8]; 2] - 370..378 '[arr; 2]': [&[u8]; 2] - 371..374 'arr': &[u8; 1] - 376..377 '2': usize - 388..389 'g': (&[u8], &[u8]) - 406..416 '(arr, arr)': (&[u8], &[u8]) - 407..410 'arr': &[u8; 1] - 412..415 'arr': &[u8; 1] - "#]], ); } #[test] -fn infer_let_stmt_coerce() { - check_infer( +fn let_stmt_coerce() { + check_no_mismatches( r" - fn test() { - let x: &[isize] = &[1]; - let x: *const [isize] = &[1]; - } - ", - expect![[r#" - 10..75 '{ ...[1]; }': () - 20..21 'x': &[isize] - 34..38 '&[1]': &[isize; 1] - 35..38 '[1]': [isize; 1] - 36..37 '1': isize - 48..49 'x': *const [isize] - 68..72 '&[1]': &[isize; 1] - 69..72 '[1]': [isize; 1] - 70..71 '1': isize - "#]], +//- minicore: coerce_unsized +fn test() { + let x: &[isize] = &[1]; + let x: *const [isize] = &[1]; +} +", ); } #[test] -fn infer_custom_coerce_unsized() { - check_infer( +fn custom_coerce_unsized() { + check( r#" //- minicore: coerce_unsized use core::{marker::Unsize, ops::CoerceUnsized}; @@ -138,46 +77,22 @@ fn foo3(x: C<[T]>) -> C<[T]> { x } fn test(a: A<[u8; 2]>, b: B<[u8; 2]>, c: C<[u8; 2]>) { let d = foo1(a); + // ^ expected A<[{unknown}]>, got A<[u8; 2]> let e = foo2(b); + // ^ type: B<[u8]> let f = foo3(c); + // ^ type: C<[u8]> } "#, - expect![[r#" - 306..307 'x': A<[T]> - 327..332 '{ x }': A<[T]> - 329..330 'x': A<[T]> - 344..345 'x': B<[T]> - 365..370 '{ x }': B<[T]> - 367..368 'x': B<[T]> - 382..383 'x': C<[T]> - 403..408 '{ x }': C<[T]> - 405..406 'x': C<[T]> - 418..419 'a': A<[u8; 2]> - 433..434 'b': B<[u8; 2]> - 448..449 'c': C<[u8; 2]> - 463..529 '{ ...(c); }': () - 473..474 'd': A<[{unknown}]> - 477..481 'foo1': fn foo1<{unknown}>(A<[{unknown}]>) -> A<[{unknown}]> - 477..484 'foo1(a)': A<[{unknown}]> - 482..483 'a': A<[u8; 2]> - 494..495 'e': B<[u8]> - 498..502 'foo2': fn foo2(B<[u8]>) -> B<[u8]> - 498..505 'foo2(b)': B<[u8]> - 503..504 'b': B<[u8; 2]> - 515..516 'f': C<[u8]> - 519..523 'foo3': fn foo3(C<[u8]>) -> C<[u8]> - 519..526 'foo3(c)': C<[u8]> - 524..525 'c': C<[u8; 2]> - "#]], ); } #[test] -fn infer_if_coerce() { - check_infer( +fn if_coerce() { + check_no_mismatches( r#" -//- minicore: unsize -fn foo(x: &[T]) -> &[T] { loop {} } +//- minicore: coerce_unsized +fn foo(x: &[T]) -> &[T] { x } fn test() { let x = if true { foo(&[1]) @@ -186,35 +101,15 @@ fn test() { }; } "#, - expect![[r#" - 10..11 'x': &[T] - 27..38 '{ loop {} }': &[T] - 29..36 'loop {}': ! - 34..36 '{}': () - 49..125 '{ ... }; }': () - 59..60 'x': &[i32] - 63..122 'if tru... }': &[i32] - 66..70 'true': bool - 71..96 '{ ... }': &[i32] - 81..84 'foo': fn foo(&[i32]) -> &[i32] - 81..90 'foo(&[1])': &[i32] - 85..89 '&[1]': &[i32; 1] - 86..89 '[1]': [i32; 1] - 87..88 '1': i32 - 102..122 '{ ... }': &[i32; 1] - 112..116 '&[1]': &[i32; 1] - 113..116 '[1]': [i32; 1] - 114..115 '1': i32 - "#]], ); } #[test] -fn infer_if_else_coerce() { - check_infer( +fn if_else_coerce() { + check_no_mismatches( r#" //- minicore: coerce_unsized -fn foo(x: &[T]) -> &[T] { loop {} } +fn foo(x: &[T]) -> &[T] { x } fn test() { let x = if true { &[1] @@ -223,35 +118,15 @@ fn test() { }; } "#, - expect![[r#" - 10..11 'x': &[T] - 27..38 '{ loop {} }': &[T] - 29..36 'loop {}': ! - 34..36 '{}': () - 49..125 '{ ... }; }': () - 59..60 'x': &[i32] - 63..122 'if tru... }': &[i32] - 66..70 'true': bool - 71..91 '{ ... }': &[i32; 1] - 81..85 '&[1]': &[i32; 1] - 82..85 '[1]': [i32; 1] - 83..84 '1': i32 - 97..122 '{ ... }': &[i32] - 107..110 'foo': fn foo(&[i32]) -> &[i32] - 107..116 'foo(&[1])': &[i32] - 111..115 '&[1]': &[i32; 1] - 112..115 '[1]': [i32; 1] - 113..114 '1': i32 - "#]], ) } #[test] -fn infer_match_first_coerce() { - check_infer( +fn match_first_coerce() { + check_no_mismatches( r#" -//- minicore: unsize -fn foo(x: &[T]) -> &[T] { loop {} } +//- minicore: coerce_unsized +fn foo(x: &[T]) -> &[T] { x } fn test(i: i32) { let x = match i { 2 => foo(&[2]), @@ -260,39 +135,12 @@ fn test(i: i32) { }; } "#, - expect![[r#" - 10..11 'x': &[T] - 27..38 '{ loop {} }': &[T] - 29..36 'loop {}': ! - 34..36 '{}': () - 47..48 'i': i32 - 55..149 '{ ... }; }': () - 65..66 'x': &[i32] - 69..146 'match ... }': &[i32] - 75..76 'i': i32 - 87..88 '2': i32 - 87..88 '2': i32 - 92..95 'foo': fn foo(&[i32]) -> &[i32] - 92..101 'foo(&[2])': &[i32] - 96..100 '&[2]': &[i32; 1] - 97..100 '[2]': [i32; 1] - 98..99 '2': i32 - 111..112 '1': i32 - 111..112 '1': i32 - 116..120 '&[1]': &[i32; 1] - 117..120 '[1]': [i32; 1] - 118..119 '1': i32 - 130..131 '_': i32 - 135..139 '&[3]': &[i32; 1] - 136..139 '[3]': [i32; 1] - 137..138 '3': i32 - "#]], ); } #[test] -fn infer_match_second_coerce() { - check_infer( +fn match_second_coerce() { + check_no_mismatches( r#" //- minicore: coerce_unsized fn foo(x: &[T]) -> &[T] { loop {} } @@ -304,33 +152,6 @@ fn test(i: i32) { }; } "#, - expect![[r#" - 10..11 'x': &[T] - 27..38 '{ loop {} }': &[T] - 29..36 'loop {}': ! - 34..36 '{}': () - 47..48 'i': i32 - 55..149 '{ ... }; }': () - 65..66 'x': &[i32] - 69..146 'match ... }': &[i32] - 75..76 'i': i32 - 87..88 '1': i32 - 87..88 '1': i32 - 92..96 '&[1]': &[i32; 1] - 93..96 '[1]': [i32; 1] - 94..95 '1': i32 - 106..107 '2': i32 - 106..107 '2': i32 - 111..114 'foo': fn foo(&[i32]) -> &[i32] - 111..120 'foo(&[2])': &[i32] - 115..119 '&[2]': &[i32; 1] - 116..119 '[2]': [i32; 1] - 117..118 '2': i32 - 130..131 '_': i32 - 135..139 '&[3]': &[i32; 1] - 136..139 '[3]': [i32; 1] - 137..138 '3': i32 - "#]], ); } @@ -338,94 +159,52 @@ fn test(i: i32) { fn coerce_merge_one_by_one1() { cov_mark::check!(coerce_merge_fail_fallback); - check_infer( + check( r" - fn test() { - let t = &mut 1; - let x = match 1 { - 1 => t as *mut i32, - 2 => t as &i32, - _ => t as *const i32, - }; - } +fn test() { + let t = &mut 1; + let x = match 1 { + 1 => t as *mut i32, + 2 => t as &i32, + //^^^^^^^^^ expected *mut i32, got &i32 + _ => t as *const i32, + }; + x; + //^ type: *const i32 +} ", - expect![[r" - 10..144 '{ ... }; }': () - 20..21 't': &mut i32 - 24..30 '&mut 1': &mut i32 - 29..30 '1': i32 - 40..41 'x': *const i32 - 44..141 'match ... }': *const i32 - 50..51 '1': i32 - 62..63 '1': i32 - 62..63 '1': i32 - 67..68 't': &mut i32 - 67..80 't as *mut i32': *mut i32 - 90..91 '2': i32 - 90..91 '2': i32 - 95..96 't': &mut i32 - 95..104 't as &i32': &i32 - 114..115 '_': i32 - 119..120 't': &mut i32 - 119..134 't as *const i32': *const i32 - "]], ); } #[test] fn return_coerce_unknown() { - check_infer_with_mismatches( + check_types( r" - fn foo() -> u32 { - return unknown; - } +fn foo() -> u32 { + return unknown; + //^^^^^^^ u32 +} ", - expect![[r" - 16..39 '{ ...own; }': u32 - 22..36 'return unknown': ! - 29..36 'unknown': u32 - "]], ); } #[test] fn coerce_autoderef() { - check_infer_with_mismatches( + check_no_mismatches( r" - struct Foo; - fn takes_ref_foo(x: &Foo) {} - fn test() { - takes_ref_foo(&Foo); - takes_ref_foo(&&Foo); - takes_ref_foo(&&&Foo); - } - ", - expect![[r" - 29..30 'x': &Foo - 38..40 '{}': () - 51..132 '{ ...oo); }': () - 57..70 'takes_ref_foo': fn takes_ref_foo(&Foo) - 57..76 'takes_...(&Foo)': () - 71..75 '&Foo': &Foo - 72..75 'Foo': Foo - 82..95 'takes_ref_foo': fn takes_ref_foo(&Foo) - 82..102 'takes_...&&Foo)': () - 96..101 '&&Foo': &&Foo - 97..101 '&Foo': &Foo - 98..101 'Foo': Foo - 108..121 'takes_ref_foo': fn takes_ref_foo(&Foo) - 108..129 'takes_...&&Foo)': () - 122..128 '&&&Foo': &&&Foo - 123..128 '&&Foo': &&Foo - 124..128 '&Foo': &Foo - 125..128 'Foo': Foo - "]], +struct Foo; +fn takes_ref_foo(x: &Foo) {} +fn test() { + takes_ref_foo(&Foo); + takes_ref_foo(&&Foo); + takes_ref_foo(&&&Foo); +}", ); } #[test] fn coerce_autoderef_generic() { - check_infer_with_mismatches( + check_no_mismatches( r#" struct Foo; fn takes_ref(x: &T) -> T { *x } @@ -435,34 +214,12 @@ fn test() { takes_ref(&&&Foo); } "#, - expect![[r" - 28..29 'x': &T - 40..46 '{ *x }': T - 42..44 '*x': T - 43..44 'x': &T - 57..126 '{ ...oo); }': () - 63..72 'takes_ref': fn takes_ref(&Foo) -> Foo - 63..78 'takes_ref(&Foo)': Foo - 73..77 '&Foo': &Foo - 74..77 'Foo': Foo - 84..93 'takes_ref': fn takes_ref<&Foo>(&&Foo) -> &Foo - 84..100 'takes_...&&Foo)': &Foo - 94..99 '&&Foo': &&Foo - 95..99 '&Foo': &Foo - 96..99 'Foo': Foo - 106..115 'takes_ref': fn takes_ref<&&Foo>(&&&Foo) -> &&Foo - 106..123 'takes_...&&Foo)': &&Foo - 116..122 '&&&Foo': &&&Foo - 117..122 '&&Foo': &&Foo - 118..122 '&Foo': &Foo - 119..122 'Foo': Foo - "]], ); } #[test] fn coerce_autoderef_block() { - check_infer_with_mismatches( + check_no_mismatches( r#" //- minicore: deref struct String {} @@ -473,71 +230,32 @@ fn test() { takes_ref_str(&{ returns_string() }); } "#, - expect![[r#" - 90..91 'x': &str - 99..101 '{}': () - 132..143 '{ loop {} }': String - 134..141 'loop {}': ! - 139..141 '{}': () - 154..199 '{ ... }); }': () - 160..173 'takes_ref_str': fn takes_ref_str(&str) - 160..196 'takes_...g() })': () - 174..195 '&{ ret...ng() }': &String - 175..195 '{ retu...ng() }': String - 177..191 'returns_string': fn returns_string() -> String - 177..193 'return...ring()': String - "#]], ); } #[test] fn closure_return_coerce() { - check_infer_with_mismatches( + check_no_mismatches( r" - fn foo() { - let x = || { - if true { - return &1u32; - } - &&1u32 - }; +fn foo() { + let x = || { + if true { + return &1u32; } - ", - expect![[r" - 9..105 '{ ... }; }': () - 19..20 'x': || -> &u32 - 23..102 '|| { ... }': || -> &u32 - 26..102 '{ ... }': &u32 - 36..81 'if tru... }': () - 39..43 'true': bool - 44..81 '{ ... }': () - 58..70 'return &1u32': ! - 65..70 '&1u32': &u32 - 66..70 '1u32': u32 - 90..96 '&&1u32': &&u32 - 91..96 '&1u32': &u32 - 92..96 '1u32': u32 - "]], + &&1u32 + }; +}", ); } #[test] fn coerce_fn_item_to_fn_ptr() { - check_infer_with_mismatches( + check_no_mismatches( r" - fn foo(x: u32) -> isize { 1 } - fn test() { - let f: fn(u32) -> isize = foo; - } - ", - expect![[r" - 7..8 'x': u32 - 24..29 '{ 1 }': isize - 26..27 '1': isize - 40..78 '{ ...foo; }': () - 50..51 'f': fn(u32) -> isize - 72..75 'foo': fn foo(u32) -> isize - "]], +fn foo(x: u32) -> isize { 1 } +fn test() { + let f: fn(u32) -> isize = foo; +}", ); } @@ -545,110 +263,62 @@ fn coerce_fn_item_to_fn_ptr() { fn coerce_fn_items_in_match_arms() { cov_mark::check!(coerce_fn_reification); - check_infer_with_mismatches( + check_types( r" - fn foo1(x: u32) -> isize { 1 } - fn foo2(x: u32) -> isize { 2 } - fn foo3(x: u32) -> isize { 3 } - fn test() { - let x = match 1 { - 1 => foo1, - 2 => foo2, - _ => foo3, - }; - } - ", - expect![[r" - 8..9 'x': u32 - 25..30 '{ 1 }': isize - 27..28 '1': isize - 39..40 'x': u32 - 56..61 '{ 2 }': isize - 58..59 '2': isize - 70..71 'x': u32 - 87..92 '{ 3 }': isize - 89..90 '3': isize - 103..192 '{ ... }; }': () - 113..114 'x': fn(u32) -> isize - 117..189 'match ... }': fn(u32) -> isize - 123..124 '1': i32 - 135..136 '1': i32 - 135..136 '1': i32 - 140..144 'foo1': fn foo1(u32) -> isize - 154..155 '2': i32 - 154..155 '2': i32 - 159..163 'foo2': fn foo2(u32) -> isize - 173..174 '_': i32 - 178..182 'foo3': fn foo3(u32) -> isize - "]], +fn foo1(x: u32) -> isize { 1 } +fn foo2(x: u32) -> isize { 2 } +fn foo3(x: u32) -> isize { 3 } +fn test() { + let x = match 1 { + 1 => foo1, + 2 => foo2, + _ => foo3, + }; + x; + //^ fn(u32) -> isize +}", ); } #[test] fn coerce_closure_to_fn_ptr() { - check_infer_with_mismatches( + check_no_mismatches( r" - fn test() { - let f: fn(u32) -> isize = |x| { 1 }; - } - ", - expect![[r" - 10..54 '{ ...1 }; }': () - 20..21 'f': fn(u32) -> isize - 42..51 '|x| { 1 }': |u32| -> isize - 43..44 'x': u32 - 46..51 '{ 1 }': isize - 48..49 '1': isize - "]], +fn test() { + let f: fn(u32) -> isize = |x| { 1 }; +}", ); } #[test] fn coerce_placeholder_ref() { // placeholders should unify, even behind references - check_infer_with_mismatches( + check_no_mismatches( r" - struct S { t: T } - impl S { - fn get(&self) -> &TT { - &self.t - } - } - ", - expect![[r" - 50..54 'self': &S - 63..86 '{ ... }': &TT - 73..80 '&self.t': &TT - 74..78 'self': &S - 74..80 'self.t': TT - "]], +struct S { t: T } +impl S { + fn get(&self) -> &TT { + &self.t + } +}", ); } #[test] fn coerce_unsize_array() { - check_infer_with_mismatches( + check_types( r#" //- minicore: coerce_unsized fn test() { let f: &[usize] = &[1, 2, 3]; -} - "#, - expect![[r#" - 10..47 '{ ... 3]; }': () - 20..21 'f': &[usize] - 34..44 '&[1, 2, 3]': &[usize; 3] - 35..44 '[1, 2, 3]': [usize; 3] - 36..37 '1': usize - 39..40 '2': usize - 42..43 '3': usize - "#]], + //^ usize +}"#, ); } #[test] fn coerce_unsize_trait_object_simple() { - check_infer_with_mismatches( + check_types( r#" //- minicore: coerce_unsized trait Foo {} @@ -662,88 +332,18 @@ impl Baz for S {} fn test() { let obj: &dyn Baz = &S; + //^ S let obj: &dyn Bar<_, i8, i16> = &S; + //^ S let obj: &dyn Foo = &S; -} -"#, - expect![[r#" - 236..351 '{ ... &S; }': () - 246..249 'obj': &dyn Baz - 271..273 '&S': &S - 272..273 'S': S - 283..286 'obj': &dyn Bar - 311..313 '&S': &S - 312..313 'S': S - 323..326 'obj': &dyn Foo - 346..348 '&S': &S - 347..348 'S': S - "#]], - ); -} - -#[test] -fn coerce_unsize_trait_object_to_trait_object() { - // FIXME: The rust reference says this should be possible, but rustc doesn't - // implement it. We used to support it, but Chalk doesn't. Here's the - // correct expect: - // - // 424..609 '{ ...bj2; }': () - // 434..437 'obj': &dyn Baz - // 459..461 '&S': &S - // 460..461 'S': S - // 471..474 'obj': &dyn Bar - // 496..499 'obj': &dyn Baz - // 509..512 'obj': &dyn Foo - // 531..534 'obj': &dyn Bar - // 544..548 'obj2': &dyn Baz - // 570..572 '&S': &S - // 571..572 'S': S - // 582..583 '_': &dyn Foo - // 602..606 'obj2': &dyn Baz - check_infer_with_mismatches( - r#" -//- minicore: coerce_unsized -trait Foo {} -trait Bar: Foo {} -trait Baz: Bar {} - -struct S; -impl Foo for S {} -impl Bar for S {} -impl Baz for S {} - -fn test() { - let obj: &dyn Baz = &S; - let obj: &dyn Bar<_, _, _> = obj; - let obj: &dyn Foo<_, _> = obj; - let obj2: &dyn Baz = &S; - let _: &dyn Foo<_, _> = obj2; -} -"#, - expect![[r#" - 236..421 '{ ...bj2; }': () - 246..249 'obj': &dyn Baz - 271..273 '&S': &S - 272..273 'S': S - 283..286 'obj': &dyn Bar<{unknown}, {unknown}, {unknown}> - 308..311 'obj': &dyn Baz - 321..324 'obj': &dyn Foo<{unknown}, {unknown}> - 343..346 'obj': &dyn Bar<{unknown}, {unknown}, {unknown}> - 356..360 'obj2': &dyn Baz - 382..384 '&S': &S - 383..384 'S': S - 394..395 '_': &dyn Foo<{unknown}, {unknown}> - 414..418 'obj2': &dyn Baz - 308..311: expected &dyn Bar<{unknown}, {unknown}, {unknown}>, got &dyn Baz - 343..346: expected &dyn Foo<{unknown}, {unknown}>, got &dyn Bar<{unknown}, {unknown}, {unknown}> - 414..418: expected &dyn Foo<{unknown}, {unknown}>, got &dyn Baz - "#]], + //^ S +}"#, ); } #[test] fn coerce_unsize_super_trait_cycle() { - check_infer_with_mismatches( + check_no_mismatches( r#" //- minicore: coerce_unsized trait A {} @@ -762,22 +362,13 @@ fn test() { let obj: &dyn A = &S; } "#, - expect![[r#" - 140..195 '{ ... &S; }': () - 150..153 'obj': &dyn D - 164..166 '&S': &S - 165..166 'S': S - 176..179 'obj': &dyn A - 190..192 '&S': &S - 191..192 'S': S - "#]], ); } #[test] fn coerce_unsize_generic() { // FIXME: fix the type mismatches here - check_infer_with_mismatches( + check( r#" //- minicore: coerce_unsized struct Foo { t: T }; @@ -785,58 +376,32 @@ struct Bar(Foo); fn test() { let _: &Foo<[usize]> = &Foo { t: [1, 2, 3] }; + //^^^^^^^^^ expected [usize], got [usize; 3] let _: &Bar<[usize]> = &Bar(Foo { t: [1, 2, 3] }); + //^^^^^^^^^^^^^^^^^^^^^^^^^^ expected &Bar<[usize]>, got &Bar<[i32; 3]> } "#, - expect![[r#" - 58..166 '{ ... }); }': () - 68..69 '_': &Foo<[usize]> - 87..108 '&Foo {..., 3] }': &Foo<[usize]> - 88..108 'Foo { ..., 3] }': Foo<[usize]> - 97..106 '[1, 2, 3]': [usize; 3] - 98..99 '1': usize - 101..102 '2': usize - 104..105 '3': usize - 118..119 '_': &Bar<[usize]> - 137..163 '&Bar(F... 3] })': &Bar<[i32; 3]> - 138..141 'Bar': Bar<[i32; 3]>(Foo<[i32; 3]>) -> Bar<[i32; 3]> - 138..163 'Bar(Fo... 3] })': Bar<[i32; 3]> - 142..162 'Foo { ..., 3] }': Foo<[i32; 3]> - 151..160 '[1, 2, 3]': [i32; 3] - 152..153 '1': i32 - 155..156 '2': i32 - 158..159 '3': i32 - 97..106: expected [usize], got [usize; 3] - 137..163: expected &Bar<[usize]>, got &Bar<[i32; 3]> - "#]], ); } #[test] fn coerce_unsize_apit() { // FIXME: #8984 - check_infer_with_mismatches( + check( r#" //- minicore: coerce_unsized trait Foo {} fn test(f: impl Foo) { let _: &dyn Foo = &f; + //^^ expected &dyn Foo, got &impl Foo } "#, - expect![[r#" - 22..23 'f': impl Foo - 35..64 '{ ... &f; }': () - 45..46 '_': &dyn Foo - 59..61 '&f': &impl Foo - 60..61 'f': impl Foo - 59..61: expected &dyn Foo, got &impl Foo - "#]], ); } #[test] -fn infer_two_closures_lub() { +fn two_closures_lub() { check_types( r#" fn foo(c: i32) { @@ -851,7 +416,7 @@ fn foo(c: i32) { } #[test] -fn infer_match_diverging_branch_1() { +fn match_diverging_branch_1() { check_types( r#" enum Result { Ok(T), Err } @@ -870,7 +435,7 @@ fn test() -> i32 { } #[test] -fn infer_match_diverging_branch_2() { +fn match_diverging_branch_2() { // same as 1 except for order of branches check_types( r#" -- cgit v1.2.3