crates/hir_ty/src/tests/coercion.rs

   1 use super::{check, check_no_mismatches, check_types};
   2
   3 #[test]
   4 fn block_expr_type_mismatch() {
   5     // FIXME fix double type mismatch
   6     check(
   7         r"
   8 fn test() {
   9     let a: i32 = { 1i64 };
  10               // ^^^^^^^^ expected i32, got i64
  11                 // ^^^^ expected i32, got i64
  12 }
  13         ",
  14     );
  15 }
  16
  17 #[test]
  18 fn coerce_places() {
  19     check_no_mismatches(
  20         r#"
  21 //- minicore: coerce_unsized
  22 struct S<T> { a: T }
  23
  24 fn f<T>(_: &[T]) -> T { loop {} }
  25 fn g<T>(_: S<&[T]>) -> T { loop {} }
  26
  27 fn gen<T>() -> *mut [T; 2] { loop {} }
  28 fn test1<U>() -> *mut [U] {
  29     gen()
  30 }
  31
  32 fn test2() {
  33     let arr: &[u8; 1] = &[1];
  34
  35     let a: &[_] = arr;
  36     let b = f(arr);
  37     let c: &[_] = { arr };
  38     let d = g(S { a: arr });
  39     let e: [&[_]; 1] = [arr];
  40     let f: [&[_]; 2] = [arr; 2];
  41     let g: (&[_], &[_]) = (arr, arr);
  42 }
  43 "#,
  44     );
  45 }
  46
  47 #[test]
  48 fn let_stmt_coerce() {
  49     check_no_mismatches(
  50         r"
  51 //- minicore: coerce_unsized
  52 fn test() {
  53     let x: &[isize] = &[1];
  54                    // ^^^^ adjustments: Deref(None), Borrow(Ref(Not)), Pointer(Unsize)
  55     let x: *const [isize] = &[1];
  56                          // ^^^^ adjustments: Deref(None), Borrow(RawPtr(Not)), Pointer(Unsize)
  57 }
  58 ",
  59     );
  60 }
  61
  62 #[test]
  63 fn custom_coerce_unsized() {
  64     check(
  65         r#"
  66 //- minicore: coerce_unsized
  67 use core::{marker::Unsize, ops::CoerceUnsized};
  68
  69 struct A<T: ?Sized>(*const T);
  70 struct B<T: ?Sized>(*const T);
  71 struct C<T: ?Sized> { inner: *const T }
  72
  73 impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<B<U>> for B<T> {}
  74 impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<C<U>> for C<T> {}
  75
  76 fn foo1<T>(x: A<[T]>) -> A<[T]> { x }
  77 fn foo2<T>(x: B<[T]>) -> B<[T]> { x }
  78 fn foo3<T>(x: C<[T]>) -> C<[T]> { x }
  79
  80 fn test(a: A<[u8; 2]>, b: B<[u8; 2]>, c: C<[u8; 2]>) {
  81     let d = foo1(a);
  82               // ^ expected A<[{unknown}]>, got A<[u8; 2]>
  83     let e = foo2(b);
  84      // ^ type: B<[u8]>
  85     let f = foo3(c);
  86      // ^ type: C<[u8]>
  87 }
  88 "#,
  89     );
  90 }
  91
  92 #[test]
  93 fn if_coerce() {
  94     check_no_mismatches(
  95         r#"
  96 //- minicore: coerce_unsized
  97 fn foo<T>(x: &[T]) -> &[T] { x }
  98 fn test() {
  99     let x = if true {
 100         foo(&[1])
 101          // ^^^^ adjustments: Deref(None), Borrow(Ref(Not)), Pointer(Unsize)
 102     } else {
 103         &[1]
 104     };
 105 }
 106 "#,
 107     );
 108 }
 109
 110 #[test]
 111 fn if_else_coerce() {
 112     check_no_mismatches(
 113         r#"
 114 //- minicore: coerce_unsized
 115 fn foo<T>(x: &[T]) -> &[T] { x }
 116 fn test() {
 117     let x = if true {
 118         &[1]
 119     } else {
 120         foo(&[1])
 121     };
 122 }
 123 "#,
 124     )
 125 }
 126
 127 #[test]
 128 fn match_first_coerce() {
 129     check_no_mismatches(
 130         r#"
 131 //- minicore: coerce_unsized
 132 fn foo<T>(x: &[T]) -> &[T] { x }
 133 fn test(i: i32) {
 134     let x = match i {
 135         2 => foo(&[2]),
 136               // ^^^^ adjustments: Deref(None), Borrow(Ref(Not)), Pointer(Unsize)
 137         1 => &[1],
 138         _ => &[3],
 139     };
 140 }
 141 "#,
 142     );
 143 }
 144
 145 #[test]
 146 fn match_second_coerce() {
 147     check_no_mismatches(
 148         r#"
 149 //- minicore: coerce_unsized
 150 fn foo<T>(x: &[T]) -> &[T] { loop {} }
 151                           // ^^^^^^^ adjustments: NeverToAny
 152 fn test(i: i32) {
 153     let x = match i {
 154         1 => &[1],
 155         2 => foo(&[2]),
 156         _ => &[3],
 157     };
 158 }
 159 "#,
 160     );
 161 }
 162
 163 #[test]
 164 fn coerce_merge_one_by_one1() {
 165     cov_mark::check!(coerce_merge_fail_fallback);
 166
 167     check(
 168         r"
 169 fn test() {
 170     let t = &mut 1;
 171     let x = match 1 {
 172         1 => t as *mut i32,
 173         2 => t as &i32,
 174            //^^^^^^^^^ expected *mut i32, got &i32
 175         _ => t as *const i32,
 176           // ^^^^^^^^^^^^^^^ adjustments: Pointer(MutToConstPointer)
 177
 178     };
 179     x;
 180   //^ type: *const i32
 181
 182 }
 183         ",
 184     );
 185 }
 186
 187 #[test]
 188 fn return_coerce_unknown() {
 189     check_types(
 190         r"
 191 fn foo() -> u32 {
 192     return unknown;
 193          //^^^^^^^ u32
 194 }
 195         ",
 196     );
 197 }
 198
 199 #[test]
 200 fn coerce_autoderef() {
 201     check_no_mismatches(
 202         r"
 203 struct Foo;
 204 fn takes_ref_foo(x: &Foo) {}
 205 fn test() {
 206     takes_ref_foo(&Foo);
 207     takes_ref_foo(&&Foo);
 208     takes_ref_foo(&&&Foo);
 209 }",
 210     );
 211 }
 212
 213 #[test]
 214 fn coerce_autoderef_generic() {
 215     check_no_mismatches(
 216         r#"
 217 struct Foo;
 218 fn takes_ref<T>(x: &T) -> T { *x }
 219 fn test() {
 220     takes_ref(&Foo);
 221     takes_ref(&&Foo);
 222     takes_ref(&&&Foo);
 223 }
 224 "#,
 225     );
 226 }
 227
 228 #[test]
 229 fn coerce_autoderef_block() {
 230     check_no_mismatches(
 231         r#"
 232 //- minicore: deref
 233 struct String {}
 234 impl core::ops::Deref for String { type Target = str; }
 235 fn takes_ref_str(x: &str) {}
 236 fn returns_string() -> String { loop {} }
 237 fn test() {
 238     takes_ref_str(&{ returns_string() });
 239                // ^^^^^^^^^^^^^^^^^^^^^ adjustments: Deref(None), Deref(Some(OverloadedDeref(Not))), Borrow(Ref(Not))
 240 }
 241 "#,
 242     );
 243 }
 244
 245 #[test]
 246 fn closure_return_coerce() {
 247     check_no_mismatches(
 248         r"
 249 fn foo() {
 250     let x = || {
 251         if true {
 252             return &1u32;
 253         }
 254         &&1u32
 255     };
 256 }",
 257     );
 258 }
 259
 260 #[test]
 261 fn coerce_fn_item_to_fn_ptr() {
 262     check_no_mismatches(
 263         r"
 264 fn foo(x: u32) -> isize { 1 }
 265 fn test() {
 266     let f: fn(u32) -> isize = foo;
 267                            // ^^^ adjustments: Pointer(ReifyFnPointer)
 268     let f: unsafe fn(u32) -> isize = foo;
 269                                   // ^^^ adjustments: Pointer(ReifyFnPointer)
 270 }",
 271     );
 272 }
 273
 274 #[test]
 275 fn coerce_fn_items_in_match_arms() {
 276     cov_mark::check!(coerce_fn_reification);
 277
 278     check_types(
 279         r"
 280 fn foo1(x: u32) -> isize { 1 }
 281 fn foo2(x: u32) -> isize { 2 }
 282 fn foo3(x: u32) -> isize { 3 }
 283 fn test() {
 284     let x = match 1 {
 285         1 => foo1,
 286         2 => foo2,
 287         _ => foo3,
 288     };
 289     x;
 290   //^ fn(u32) -> isize
 291 }",
 292     );
 293 }
 294
 295 #[test]
 296 fn coerce_closure_to_fn_ptr() {
 297     check_no_mismatches(
 298         r"
 299 fn test() {
 300     let f: fn(u32) -> isize = |x| { 1 };
 301 }",
 302     );
 303 }
 304
 305 #[test]
 306 fn coerce_placeholder_ref() {
 307     // placeholders should unify, even behind references
 308     check_no_mismatches(
 309         r"
 310 struct S<T> { t: T }
 311 impl<TT> S<TT> {
 312     fn get(&self) -> &TT {
 313         &self.t
 314     }
 315 }",
 316     );
 317 }
 318
 319 #[test]
 320 fn coerce_unsize_array() {
 321     check_types(
 322         r#"
 323 //- minicore: coerce_unsized
 324 fn test() {
 325     let f: &[usize] = &[1, 2, 3];
 326                       //^ usize
 327 }"#,
 328     );
 329 }
 330
 331 #[test]
 332 fn coerce_unsize_trait_object_simple() {
 333     check_types(
 334         r#"
 335 //- minicore: coerce_unsized
 336 trait Foo<T, U> {}
 337 trait Bar<U, T, X>: Foo<T, U> {}
 338 trait Baz<T, X>: Bar<usize, T, X> {}
 339
 340 struct S<T, X>;
 341 impl<T, X> Foo<T, usize> for S<T, X> {}
 342 impl<T, X> Bar<usize, T, X> for S<T, X> {}
 343 impl<T, X> Baz<T, X> for S<T, X> {}
 344
 345 fn test() {
 346     let obj: &dyn Baz<i8, i16> = &S;
 347                                 //^ S<i8, i16>
 348     let obj: &dyn Bar<_, i8, i16> = &S;
 349                                    //^ S<i8, i16>
 350     let obj: &dyn Foo<i8, _> = &S;
 351                               //^ S<i8, {unknown}>
 352 }"#,
 353     );
 354 }
 355
 356 #[test]
 357 fn coerce_unsize_super_trait_cycle() {
 358     check_no_mismatches(
 359         r#"
 360 //- minicore: coerce_unsized
 361 trait A {}
 362 trait B: C + A {}
 363 trait C: B {}
 364 trait D: C
 365
 366 struct S;
 367 impl A for S {}
 368 impl B for S {}
 369 impl C for S {}
 370 impl D for S {}
 371
 372 fn test() {
 373     let obj: &dyn D = &S;
 374     let obj: &dyn A = &S;
 375 }
 376 "#,
 377     );
 378 }
 379
 380 #[test]
 381 fn coerce_unsize_generic() {
 382     // FIXME: fix the type mismatches here
 383     check(
 384         r#"
 385 //- minicore: coerce_unsized
 386 struct Foo<T> { t: T };
 387 struct Bar<T>(Foo<T>);
 388
 389 fn test() {
 390     let _: &Foo<[usize]> = &Foo { t: [1, 2, 3] };
 391                                    //^^^^^^^^^ expected [usize], got [usize; 3]
 392     let _: &Bar<[usize]> = &Bar(Foo { t: [1, 2, 3] });
 393                          //^^^^^^^^^^^^^^^^^^^^^^^^^^ expected &Bar<[usize]>, got &Bar<[i32; 3]>
 394 }
 395 "#,
 396     );
 397 }
 398
 399 #[test]
 400 fn coerce_unsize_apit() {
 401     // FIXME: #8984
 402     check(
 403         r#"
 404 //- minicore: coerce_unsized
 405 trait Foo {}
 406
 407 fn test(f: impl Foo) {
 408     let _: &dyn Foo = &f;
 409                     //^^ expected &dyn Foo, got &impl Foo
 410 }
 411         "#,
 412     );
 413 }
 414
 415 #[test]
 416 fn two_closures_lub() {
 417     check_types(
 418         r#"
 419 fn foo(c: i32) {
 420     let add = |a: i32, b: i32| a + b;
 421     let sub = |a, b| a - b;
 422             //^^^^^^^^^^^^ |i32, i32| -> i32
 423     if c > 42 { add } else { sub };
 424   //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ fn(i32, i32) -> i32
 425 }
 426         "#,
 427     )
 428 }
 429
 430 #[test]
 431 fn match_diverging_branch_1() {
 432     check_types(
 433         r#"
 434 enum Result<T> { Ok(T), Err }
 435 fn parse<T>() -> T { loop {} }
 436
 437 fn test() -> i32 {
 438     let a = match parse() {
 439         Ok(val) => val,
 440         Err => return 0,
 441     };
 442     a
 443   //^ i32
 444 }
 445         "#,
 446     )
 447 }
 448
 449 #[test]
 450 fn match_diverging_branch_2() {
 451     // same as 1 except for order of branches
 452     check_types(
 453         r#"
 454 enum Result<T> { Ok(T), Err }
 455 fn parse<T>() -> T { loop {} }
 456
 457 fn test() -> i32 {
 458     let a = match parse() {
 459         Err => return 0,
 460         Ok(val) => val,
 461     };
 462     a
 463   //^ i32
 464 }
 465         "#,
 466     )
 467 }
 468
 469 #[test]
 470 fn panic_macro() {
 471     check_no_mismatches(
 472         r#"
 473 mod panic {
 474     #[macro_export]
 475     pub macro panic_2015 {
 476         () => (
 477             $crate::panicking::panic()
 478         ),
 479     }
 480 }
 481
 482 mod panicking {
 483     pub fn panic() -> ! { loop {} }
 484 }
 485
 486 #[rustc_builtin_macro = "core_panic"]
 487 macro_rules! panic {
 488     // Expands to either `$crate::panic::panic_2015` or `$crate::panic::panic_2021`
 489     // depending on the edition of the caller.
 490     ($($arg:tt)*) => {
 491         /* compiler built-in */
 492     };
 493 }
 494
 495 fn main() {
 496     panic!()
 497 }
 498         "#,
 499     );
 500 }
 501
 502 #[test]
 503 fn coerce_unsize_expected_type() {
 504     check_no_mismatches(
 505         r#"
 506 //- minicore: coerce_unsized
 507 fn main() {
 508     let foo: &[u32] = &[1, 2];
 509     let foo: &[u32] = match true {
 510         true => &[1, 2],
 511         false => &[1, 2, 3],
 512     };
 513     let foo: &[u32] = if true {
 514         &[1, 2]
 515     } else {
 516         &[1, 2, 3]
 517     };
 518 }
 519         "#,
 520     );
 521 }
 522
 523 #[test]
 524 fn coerce_array_elems_lub() {
 525     check_no_mismatches(
 526         r#"
 527 fn f() {}
 528 fn g() {}
 529
 530 fn test() {
 531     [f, g];
 532 }
 533         "#,
 534     );
 535 }