crates/hir_ty/src/tests/traits.rs

   1 use expect_test::expect;
   2
   3 use super::{check_infer, check_infer_with_mismatches, check_types};
   4
   5 #[test]
   6 fn infer_await() {
   7     check_types(
   8         r#"
   9 //- minicore: future
  10 struct IntFuture;
  11
  12 impl core::future::Future for IntFuture {
  13     type Output = u64;
  14 }
  15
  16 fn test() {
  17     let r = IntFuture;
  18     let v = r.await;
  19     v;
  20 } //^ u64
  21 "#,
  22     );
  23 }
  24
  25 #[test]
  26 fn infer_async() {
  27     check_types(
  28         r#"
  29 //- minicore: future
  30 async fn foo() -> u64 { 128 }
  31
  32 fn test() {
  33     let r = foo();
  34     let v = r.await;
  35     v;
  36 } //^ u64
  37 "#,
  38     );
  39 }
  40
  41 #[test]
  42 fn infer_desugar_async() {
  43     check_types(
  44         r#"
  45 //- minicore: future
  46 async fn foo() -> u64 { 128 }
  47
  48 fn test() {
  49     let r = foo();
  50     r;
  51 } //^ impl Future<Output = u64>
  52 "#,
  53     );
  54 }
  55
  56 #[test]
  57 fn infer_async_block() {
  58     check_types(
  59         r#"
  60 //- minicore: future, option
  61 async fn test() {
  62     let a = async { 42 };
  63     a;
  64 //  ^ impl Future<Output = i32>
  65     let x = a.await;
  66     x;
  67 //  ^ i32
  68     let b = async {}.await;
  69     b;
  70 //  ^ ()
  71     let c = async {
  72         let y = None;
  73         y
  74     //  ^ Option<u64>
  75     };
  76     let _: Option<u64> = c.await;
  77     c;
  78 //  ^ impl Future<Output = Option<u64>>
  79 }
  80 "#,
  81     );
  82 }
  83
  84 #[test]
  85 fn infer_try() {
  86     check_types(
  87         r#"
  88 //- /main.rs crate:main deps:core
  89 fn test() {
  90     let r: Result<i32, u64> = Result::Ok(1);
  91     let v = r?;
  92     v;
  93 } //^ i32
  94
  95 //- /core.rs crate:core
  96 pub mod ops {
  97     pub trait Try {
  98         type Ok;
  99         type Error;
 100     }
 101 }
 102
 103 pub mod result {
 104     pub enum Result<O, E> {
 105         Ok(O),
 106         Err(E)
 107     }
 108
 109     impl<O, E> crate::ops::Try for Result<O, E> {
 110         type Ok = O;
 111         type Error = E;
 112     }
 113 }
 114
 115 pub mod prelude {
 116     pub mod rust_2018 {
 117         pub use crate::{result::*, ops::*};
 118     }
 119 }
 120 "#,
 121     );
 122 }
 123
 124 #[test]
 125 fn infer_try_trait_v2() {
 126     check_types(
 127         r#"
 128 //- /main.rs crate:main deps:core
 129 fn test() {
 130     let r: Result<i32, u64> = Result::Ok(1);
 131     let v = r?;
 132     v;
 133 } //^ i32
 134
 135 //- /core.rs crate:core
 136 mod ops {
 137     mod try_trait {
 138         pub trait Try: FromResidual {
 139             type Output;
 140             type Residual;
 141         }
 142         pub trait FromResidual<R = <Self as Try>::Residual> {}
 143     }
 144
 145     pub use self::try_trait::FromResidual;
 146     pub use self::try_trait::Try;
 147 }
 148
 149 mov convert {
 150     pub trait From<T> {}
 151     impl<T> From<T> for T {}
 152 }
 153
 154 pub mod result {
 155     use crate::convert::From;
 156     use crate::ops::{Try, FromResidual};
 157
 158     pub enum Infallible {}
 159     pub enum Result<O, E> {
 160         Ok(O),
 161         Err(E)
 162     }
 163
 164     impl<O, E> Try for Result<O, E> {
 165         type Output = O;
 166         type Error = Result<Infallible, E>;
 167     }
 168
 169     impl<T, E, F: From<E>> FromResidual<Result<Infallible, E>> for Result<T, F> {}
 170 }
 171
 172 pub mod prelude {
 173     pub mod rust_2018 {
 174         pub use crate::result::*;
 175     }
 176 }
 177 "#,
 178     );
 179 }
 180
 181 #[test]
 182 fn infer_for_loop() {
 183     check_types(
 184         r#"
 185 //- /main.rs crate:main deps:core,alloc
 186 #![no_std]
 187 use alloc::collections::Vec;
 188
 189 fn test() {
 190     let v = Vec::new();
 191     v.push("foo");
 192     for x in v {
 193         x;
 194     } //^ &str
 195 }
 196
 197 //- /core.rs crate:core
 198 pub mod iter {
 199     pub trait IntoIterator {
 200         type Item;
 201     }
 202 }
 203 pub mod prelude {
 204     pub mod rust_2018 {
 205         pub use crate::iter::*;
 206     }
 207 }
 208
 209 //- /alloc.rs crate:alloc deps:core
 210 #![no_std]
 211 mod collections {
 212     struct Vec<T> {}
 213     impl<T> Vec<T> {
 214         pub fn new() -> Self { Vec {} }
 215         pub fn push(&mut self, t: T) { }
 216     }
 217
 218     impl<T> IntoIterator for Vec<T> {
 219         type Item=T;
 220     }
 221 }
 222 "#,
 223     );
 224 }
 225
 226 #[test]
 227 fn infer_ops_neg() {
 228     check_types(
 229         r#"
 230 //- /main.rs crate:main deps:std
 231 struct Bar;
 232 struct Foo;
 233
 234 impl std::ops::Neg for Bar {
 235     type Output = Foo;
 236 }
 237
 238 fn test() {
 239     let a = Bar;
 240     let b = -a;
 241     b;
 242 } //^ Foo
 243
 244 //- /std.rs crate:std
 245 #[prelude_import] use ops::*;
 246 mod ops {
 247     #[lang = "neg"]
 248     pub trait Neg {
 249         type Output;
 250     }
 251 }
 252 "#,
 253     );
 254 }
 255
 256 #[test]
 257 fn infer_ops_not() {
 258     check_types(
 259         r#"
 260 //- /main.rs crate:main deps:std
 261 struct Bar;
 262 struct Foo;
 263
 264 impl std::ops::Not for Bar {
 265     type Output = Foo;
 266 }
 267
 268 fn test() {
 269     let a = Bar;
 270     let b = !a;
 271     b;
 272 } //^ Foo
 273
 274 //- /std.rs crate:std
 275 #[prelude_import] use ops::*;
 276 mod ops {
 277     #[lang = "not"]
 278     pub trait Not {
 279         type Output;
 280     }
 281 }
 282 "#,
 283     );
 284 }
 285
 286 #[test]
 287 fn infer_from_bound_1() {
 288     check_infer(
 289         r#"
 290 trait Trait<T> {}
 291 struct S<T>(T);
 292 impl<U> Trait<U> for S<U> {}
 293 fn foo<T: Trait<u32>>(t: T) {}
 294 fn test() {
 295     let s = S(unknown);
 296     foo(s);
 297 }"#,
 298         expect![[r#"
 299             85..86 't': T
 300             91..93 '{}': ()
 301             104..143 '{     ...(s); }': ()
 302             114..115 's': S<u32>
 303             118..119 'S': S<u32>(u32) -> S<u32>
 304             118..128 'S(unknown)': S<u32>
 305             120..127 'unknown': u32
 306             134..137 'foo': fn foo<S<u32>>(S<u32>)
 307             134..140 'foo(s)': ()
 308             138..139 's': S<u32>
 309         "#]],
 310     );
 311 }
 312
 313 #[test]
 314 fn infer_from_bound_2() {
 315     check_infer(
 316         r#"
 317 trait Trait<T> {}
 318 struct S<T>(T);
 319 impl<U> Trait<U> for S<U> {}
 320 fn foo<U, T: Trait<U>>(t: T) -> U {}
 321 fn test() {
 322     let s = S(unknown);
 323     let x: u32 = foo(s);
 324 }"#,
 325         expect![[r#"
 326             86..87 't': T
 327             97..99 '{}': ()
 328             110..162 '{     ...(s); }': ()
 329             120..121 's': S<u32>
 330             124..125 'S': S<u32>(u32) -> S<u32>
 331             124..134 'S(unknown)': S<u32>
 332             126..133 'unknown': u32
 333             144..145 'x': u32
 334             153..156 'foo': fn foo<u32, S<u32>>(S<u32>) -> u32
 335             153..159 'foo(s)': u32
 336             157..158 's': S<u32>
 337         "#]],
 338     );
 339 }
 340
 341 #[test]
 342 fn trait_default_method_self_bound_implements_trait() {
 343     cov_mark::check!(trait_self_implements_self);
 344     check_infer(
 345         r#"
 346 trait Trait {
 347     fn foo(&self) -> i64;
 348     fn bar(&self) -> {
 349         let x = self.foo();
 350     }
 351 }"#,
 352         expect![[r#"
 353             26..30 'self': &Self
 354             52..56 'self': &Self
 355             61..96 '{     ...     }': ()
 356             75..76 'x': i64
 357             79..83 'self': &Self
 358             79..89 'self.foo()': i64
 359         "#]],
 360     );
 361 }
 362
 363 #[test]
 364 fn trait_default_method_self_bound_implements_super_trait() {
 365     check_infer(
 366         r#"
 367 trait SuperTrait {
 368     fn foo(&self) -> i64;
 369 }
 370 trait Trait: SuperTrait {
 371     fn bar(&self) -> {
 372         let x = self.foo();
 373     }
 374 }"#,
 375         expect![[r#"
 376             31..35 'self': &Self
 377             85..89 'self': &Self
 378             94..129 '{     ...     }': ()
 379             108..109 'x': i64
 380             112..116 'self': &Self
 381             112..122 'self.foo()': i64
 382         "#]],
 383     );
 384 }
 385
 386 #[test]
 387 fn infer_project_associated_type() {
 388     check_infer(
 389         r#"
 390 trait Iterable {
 391     type Item;
 392 }
 393 struct S;
 394 impl Iterable for S { type Item = u32; }
 395 fn test<T: Iterable>() {
 396     let x: <S as Iterable>::Item = 1;
 397     let y: <T as Iterable>::Item = no_matter;
 398     let z: T::Item = no_matter;
 399     let a: <T>::Item = no_matter;
 400 }"#,
 401         expect![[r#"
 402             108..261 '{     ...ter; }': ()
 403             118..119 'x': u32
 404             145..146 '1': u32
 405             156..157 'y': Iterable::Item<T>
 406             183..192 'no_matter': Iterable::Item<T>
 407             202..203 'z': Iterable::Item<T>
 408             215..224 'no_matter': Iterable::Item<T>
 409             234..235 'a': Iterable::Item<T>
 410             249..258 'no_matter': Iterable::Item<T>
 411         "#]],
 412     );
 413 }
 414
 415 #[test]
 416 fn infer_return_associated_type() {
 417     check_infer(
 418         r#"
 419 trait Iterable {
 420     type Item;
 421 }
 422 struct S;
 423 impl Iterable for S { type Item = u32; }
 424 fn foo1<T: Iterable>(t: T) -> T::Item {}
 425 fn foo2<T: Iterable>(t: T) -> <T as Iterable>::Item {}
 426 fn foo3<T: Iterable>(t: T) -> <T>::Item {}
 427 fn test() {
 428     let x = foo1(S);
 429     let y = foo2(S);
 430     let z = foo3(S);
 431 }"#,
 432         expect![[r#"
 433             106..107 't': T
 434             123..125 '{}': ()
 435             147..148 't': T
 436             178..180 '{}': ()
 437             202..203 't': T
 438             221..223 '{}': ()
 439             234..300 '{     ...(S); }': ()
 440             244..245 'x': u32
 441             248..252 'foo1': fn foo1<S>(S) -> <S as Iterable>::Item
 442             248..255 'foo1(S)': u32
 443             253..254 'S': S
 444             265..266 'y': u32
 445             269..273 'foo2': fn foo2<S>(S) -> <S as Iterable>::Item
 446             269..276 'foo2(S)': u32
 447             274..275 'S': S
 448             286..287 'z': u32
 449             290..294 'foo3': fn foo3<S>(S) -> <S as Iterable>::Item
 450             290..297 'foo3(S)': u32
 451             295..296 'S': S
 452         "#]],
 453     );
 454 }
 455
 456 #[test]
 457 fn infer_associated_type_bound() {
 458     check_infer(
 459         r#"
 460 trait Iterable {
 461     type Item;
 462 }
 463 fn test<T: Iterable<Item=u32>>() {
 464     let y: T::Item = unknown;
 465 }"#,
 466         expect![[r#"
 467             67..100 '{     ...own; }': ()
 468             77..78 'y': u32
 469             90..97 'unknown': u32
 470         "#]],
 471     );
 472 }
 473
 474 #[test]
 475 fn infer_const_body() {
 476     check_infer(
 477         r#"
 478 const A: u32 = 1 + 1;
 479 static B: u64 = { let x = 1; x };"#,
 480         expect![[r#"
 481             15..16 '1': u32
 482             15..20 '1 + 1': u32
 483             19..20 '1': u32
 484             38..54 '{ let ...1; x }': u64
 485             44..45 'x': u64
 486             48..49 '1': u64
 487             51..52 'x': u64
 488         "#]],
 489     );
 490 }
 491
 492 #[test]
 493 fn tuple_struct_fields() {
 494     check_infer(
 495         r#"
 496 struct S(i32, u64);
 497 fn test() -> u64 {
 498     let a = S(4, 6);
 499     let b = a.0;
 500     a.1
 501 }"#,
 502         expect![[r#"
 503             37..86 '{     ... a.1 }': u64
 504             47..48 'a': S
 505             51..52 'S': S(i32, u64) -> S
 506             51..58 'S(4, 6)': S
 507             53..54 '4': i32
 508             56..57 '6': u64
 509             68..69 'b': i32
 510             72..73 'a': S
 511             72..75 'a.0': i32
 512             81..82 'a': S
 513             81..84 'a.1': u64
 514         "#]],
 515     );
 516 }
 517
 518 #[test]
 519 fn tuple_struct_with_fn() {
 520     check_infer(
 521         r#"
 522 struct S(fn(u32) -> u64);
 523 fn test() -> u64 {
 524     let a = S(|i| 2*i);
 525     let b = a.0(4);
 526     a.0(2)
 527 }"#,
 528         expect![[r#"
 529             43..101 '{     ...0(2) }': u64
 530             53..54 'a': S
 531             57..58 'S': S(fn(u32) -> u64) -> S
 532             57..67 'S(|i| 2*i)': S
 533             59..66 '|i| 2*i': |u32| -> u64
 534             60..61 'i': u32
 535             63..64 '2': u32
 536             63..66 '2*i': u32
 537             65..66 'i': u32
 538             77..78 'b': u64
 539             81..82 'a': S
 540             81..84 'a.0': fn(u32) -> u64
 541             81..87 'a.0(4)': u64
 542             85..86 '4': u32
 543             93..94 'a': S
 544             93..96 'a.0': fn(u32) -> u64
 545             93..99 'a.0(2)': u64
 546             97..98 '2': u32
 547         "#]],
 548     );
 549 }
 550
 551 #[test]
 552 fn indexing_arrays() {
 553     check_infer(
 554         "fn main() { &mut [9][2]; }",
 555         expect![[r#"
 556             10..26 '{ &mut...[2]; }': ()
 557             12..23 '&mut [9][2]': &mut {unknown}
 558             17..20 '[9]': [i32; 1]
 559             17..23 '[9][2]': {unknown}
 560             18..19 '9': i32
 561             21..22 '2': i32
 562         "#]],
 563     )
 564 }
 565
 566 #[test]
 567 fn infer_ops_index() {
 568     check_types(
 569         r#"
 570 //- /main.rs crate:main deps:std
 571 struct Bar;
 572 struct Foo;
 573
 574 impl std::ops::Index<u32> for Bar {
 575     type Output = Foo;
 576 }
 577
 578 fn test() {
 579     let a = Bar;
 580     let b = a[1u32];
 581     b;
 582 } //^ Foo
 583
 584 //- /std.rs crate:std
 585 #[prelude_import] use ops::*;
 586 mod ops {
 587     #[lang = "index"]
 588     pub trait Index<Idx> {
 589         type Output;
 590     }
 591 }
 592 "#,
 593     );
 594 }
 595
 596 #[test]
 597 fn infer_ops_index_int() {
 598     check_types(
 599         r#"
 600 //- /main.rs crate:main deps:std
 601 struct Bar;
 602 struct Foo;
 603
 604 impl std::ops::Index<u32> for Bar {
 605     type Output = Foo;
 606 }
 607
 608 struct Range;
 609 impl std::ops::Index<Range> for Bar {
 610     type Output = Bar;
 611 }
 612
 613 fn test() {
 614     let a = Bar;
 615     let b = a[1];
 616     b;
 617   //^ Foo
 618 }
 619
 620 //- /std.rs crate:std
 621 #[prelude_import] use ops::*;
 622 mod ops {
 623     #[lang = "index"]
 624     pub trait Index<Idx> {
 625         type Output;
 626     }
 627 }
 628 "#,
 629     );
 630 }
 631
 632 #[test]
 633 fn infer_ops_index_autoderef() {
 634     check_types(
 635         r#"
 636 //- /main.rs crate:main deps:std
 637 fn test() {
 638     let a = &[1u32, 2, 3];
 639     let b = a[1u32];
 640     b;
 641 } //^ u32
 642
 643 //- /std.rs crate:std
 644 impl<T> ops::Index<u32> for [T] {
 645     type Output = T;
 646 }
 647
 648 #[prelude_import] use ops::*;
 649 mod ops {
 650     #[lang = "index"]
 651     pub trait Index<Idx> {
 652         type Output;
 653     }
 654 }
 655 "#,
 656     );
 657 }
 658
 659 #[test]
 660 fn deref_trait() {
 661     check_types(
 662         r#"
 663 //- minicore: deref
 664 struct Arc<T>;
 665 impl<T> core::ops::Deref for Arc<T> {
 666     type Target = T;
 667 }
 668
 669 struct S;
 670 impl S {
 671     fn foo(&self) -> u128 {}
 672 }
 673
 674 fn test(s: Arc<S>) {
 675     (*s, s.foo());
 676 } //^ (S, u128)
 677 "#,
 678     );
 679 }
 680
 681 #[test]
 682 fn deref_trait_with_inference_var() {
 683     check_types(
 684         r#"
 685 //- minicore: deref
 686 struct Arc<T>;
 687 fn new_arc<T>() -> Arc<T> {}
 688 impl<T> core::ops::Deref for Arc<T> {
 689     type Target = T;
 690 }
 691
 692 struct S;
 693 fn foo(a: Arc<S>) {}
 694
 695 fn test() {
 696     let a = new_arc();
 697     let b = (*a);
 698           //^ S
 699     foo(a);
 700 }
 701 "#,
 702     );
 703 }
 704
 705 #[test]
 706 fn deref_trait_infinite_recursion() {
 707     check_types(
 708         r#"
 709 //- minicore: deref
 710 struct S;
 711
 712 impl core::ops::Deref for S {
 713     type Target = S;
 714 }
 715
 716 fn test(s: S) {
 717     s.foo();
 718 }       //^ {unknown}
 719 "#,
 720     );
 721 }
 722
 723 #[test]
 724 fn deref_trait_with_question_mark_size() {
 725     check_types(
 726         r#"
 727 //- minicore: deref
 728 struct Arc<T>;
 729 impl<T: ?Sized> core::ops::Deref for Arc<T> {
 730     type Target = T;
 731 }
 732
 733 struct S;
 734 impl S {
 735     fn foo(&self) -> u128 {}
 736 }
 737
 738 fn test(s: Arc<S>) {
 739     (*s, s.foo());
 740 } //^ (S, u128)
 741 "#,
 742     );
 743 }
 744
 745 #[test]
 746 fn obligation_from_function_clause() {
 747     check_types(
 748         r#"
 749 struct S;
 750
 751 trait Trait<T> {}
 752 impl Trait<u32> for S {}
 753
 754 fn foo<T: Trait<U>, U>(t: T) -> U {}
 755
 756 fn test(s: S) {
 757     (foo(s));
 758 } //^ u32
 759 "#,
 760     );
 761 }
 762
 763 #[test]
 764 fn obligation_from_method_clause() {
 765     check_types(
 766         r#"
 767 //- /main.rs
 768 struct S;
 769
 770 trait Trait<T> {}
 771 impl Trait<isize> for S {}
 772
 773 struct O;
 774 impl O {
 775     fn foo<T: Trait<U>, U>(&self, t: T) -> U {}
 776 }
 777
 778 fn test() {
 779     O.foo(S);
 780 }      //^ isize
 781 "#,
 782     );
 783 }
 784
 785 #[test]
 786 fn obligation_from_self_method_clause() {
 787     check_types(
 788         r#"
 789 struct S;
 790
 791 trait Trait<T> {}
 792 impl Trait<i64> for S {}
 793
 794 impl S {
 795     fn foo<U>(&self) -> U where Self: Trait<U> {}
 796 }
 797
 798 fn test() {
 799     S.foo();
 800 }       //^ i64
 801 "#,
 802     );
 803 }
 804
 805 #[test]
 806 fn obligation_from_impl_clause() {
 807     check_types(
 808         r#"
 809 struct S;
 810
 811 trait Trait<T> {}
 812 impl Trait<&str> for S {}
 813
 814 struct O<T>;
 815 impl<U, T: Trait<U>> O<T> {
 816     fn foo(&self) -> U {}
 817 }
 818
 819 fn test(o: O<S>) {
 820     o.foo();
 821 }       //^ &str
 822 "#,
 823     );
 824 }
 825
 826 #[test]
 827 fn generic_param_env_1() {
 828     check_types(
 829         r#"
 830 trait Clone {}
 831 trait Trait { fn foo(self) -> u128; }
 832 struct S;
 833 impl Clone for S {}
 834 impl<T> Trait for T where T: Clone {}
 835 fn test<T: Clone>(t: T) { t.foo(); }
 836                              //^ u128
 837 "#,
 838     );
 839 }
 840
 841 #[test]
 842 fn generic_param_env_1_not_met() {
 843     check_types(
 844         r#"
 845 //- /main.rs
 846 trait Clone {}
 847 trait Trait { fn foo(self) -> u128; }
 848 struct S;
 849 impl Clone for S {}
 850 impl<T> Trait for T where T: Clone {}
 851 fn test<T>(t: T) { t.foo(); }
 852                        //^ {unknown}
 853 "#,
 854     );
 855 }
 856
 857 #[test]
 858 fn generic_param_env_2() {
 859     check_types(
 860         r#"
 861 trait Trait { fn foo(self) -> u128; }
 862 struct S;
 863 impl Trait for S {}
 864 fn test<T: Trait>(t: T) { t.foo(); }
 865                               //^ u128
 866 "#,
 867     );
 868 }
 869
 870 #[test]
 871 fn generic_param_env_2_not_met() {
 872     check_types(
 873         r#"
 874 trait Trait { fn foo(self) -> u128; }
 875 struct S;
 876 impl Trait for S {}
 877 fn test<T>(t: T) { t.foo(); }
 878                        //^ {unknown}
 879 "#,
 880     );
 881 }
 882
 883 #[test]
 884 fn generic_param_env_deref() {
 885     check_types(
 886         r#"
 887 #[lang = "deref"]
 888 trait Deref {
 889     type Target;
 890 }
 891 trait Trait {}
 892 impl<T> Deref for T where T: Trait {
 893     type Target = i128;
 894 }
 895 fn test<T: Trait>(t: T) { (*t); }
 896                         //^ i128
 897 "#,
 898     );
 899 }
 900
 901 #[test]
 902 fn associated_type_placeholder() {
 903     // inside the generic function, the associated type gets normalized to a placeholder `ApplL::Out<T>` [https://rust-lang.github.io/rustc-guide/traits/associated-types.html#placeholder-associated-types].
 904     check_types(
 905         r#"
 906 pub trait ApplyL {
 907     type Out;
 908 }
 909
 910 pub struct RefMutL<T>;
 911
 912 impl<T> ApplyL for RefMutL<T> {
 913     type Out = <T as ApplyL>::Out;
 914 }
 915
 916 fn test<T: ApplyL>() {
 917     let y: <RefMutL<T> as ApplyL>::Out = no_matter;
 918     y;
 919 } //^ ApplyL::Out<T>
 920 "#,
 921     );
 922 }
 923
 924 #[test]
 925 fn associated_type_placeholder_2() {
 926     check_types(
 927         r#"
 928 pub trait ApplyL {
 929     type Out;
 930 }
 931 fn foo<T: ApplyL>(t: T) -> <T as ApplyL>::Out;
 932
 933 fn test<T: ApplyL>(t: T) {
 934     let y = foo(t);
 935     y;
 936 } //^ ApplyL::Out<T>
 937 "#,
 938     );
 939 }
 940
 941 #[test]
 942 fn argument_impl_trait() {
 943     check_infer_with_mismatches(
 944         r#"
 945 trait Trait<T> {
 946     fn foo(&self) -> T;
 947     fn foo2(&self) -> i64;
 948 }
 949 fn bar(x: impl Trait<u16>) {}
 950 struct S<T>(T);
 951 impl<T> Trait<T> for S<T> {}
 952
 953 fn test(x: impl Trait<u64>, y: &impl Trait<u32>) {
 954     x;
 955     y;
 956     let z = S(1);
 957     bar(z);
 958     x.foo();
 959     y.foo();
 960     z.foo();
 961     x.foo2();
 962     y.foo2();
 963     z.foo2();
 964 }"#,
 965         expect![[r#"
 966             29..33 'self': &Self
 967             54..58 'self': &Self
 968             77..78 'x': impl Trait<u16>
 969             97..99 '{}': ()
 970             154..155 'x': impl Trait<u64>
 971             174..175 'y': &impl Trait<u32>
 972             195..323 '{     ...2(); }': ()
 973             201..202 'x': impl Trait<u64>
 974             208..209 'y': &impl Trait<u32>
 975             219..220 'z': S<u16>
 976             223..224 'S': S<u16>(u16) -> S<u16>
 977             223..227 'S(1)': S<u16>
 978             225..226 '1': u16
 979             233..236 'bar': fn bar(S<u16>)
 980             233..239 'bar(z)': ()
 981             237..238 'z': S<u16>
 982             245..246 'x': impl Trait<u64>
 983             245..252 'x.foo()': u64
 984             258..259 'y': &impl Trait<u32>
 985             258..265 'y.foo()': u32
 986             271..272 'z': S<u16>
 987             271..278 'z.foo()': u16
 988             284..285 'x': impl Trait<u64>
 989             284..292 'x.foo2()': i64
 990             298..299 'y': &impl Trait<u32>
 991             298..306 'y.foo2()': i64
 992             312..313 'z': S<u16>
 993             312..320 'z.foo2()': i64
 994         "#]],
 995     );
 996 }
 997
 998 #[test]
 999 fn argument_impl_trait_type_args_1() {
1000     check_infer_with_mismatches(
1001         r#"
1002 trait Trait {}
1003 trait Foo {
1004     // this function has an implicit Self param, an explicit type param,
1005     // and an implicit impl Trait param!
1006     fn bar<T>(x: impl Trait) -> T { loop {} }
1007 }
1008 fn foo<T>(x: impl Trait) -> T { loop {} }
1009 struct S;
1010 impl Trait for S {}
1011 struct F;
1012 impl Foo for F {}
1013
1014 fn test() {
1015     Foo::bar(S);
1016     <F as Foo>::bar(S);
1017     F::bar(S);
1018     Foo::bar::<u32>(S);
1019     <F as Foo>::bar::<u32>(S);
1020
1021     foo(S);
1022     foo::<u32>(S);
1023     foo::<u32, i32>(S); // we should ignore the extraneous i32
1024 }"#,
1025         expect![[r#"
1026             155..156 'x': impl Trait
1027             175..186 '{ loop {} }': T
1028             177..184 'loop {}': !
1029             182..184 '{}': ()
1030             199..200 'x': impl Trait
1031             219..230 '{ loop {} }': T
1032             221..228 'loop {}': !
1033             226..228 '{}': ()
1034             300..509 '{     ... i32 }': ()
1035             306..314 'Foo::bar': fn bar<{unknown}, {unknown}>(S) -> {unknown}
1036             306..317 'Foo::bar(S)': {unknown}
1037             315..316 'S': S
1038             323..338 '<F as Foo>::bar': fn bar<F, {unknown}>(S) -> {unknown}
1039             323..341 '<F as ...bar(S)': {unknown}
1040             339..340 'S': S
1041             347..353 'F::bar': fn bar<F, {unknown}>(S) -> {unknown}
1042             347..356 'F::bar(S)': {unknown}
1043             354..355 'S': S
1044             362..377 'Foo::bar::<u32>': fn bar<{unknown}, u32>(S) -> u32
1045             362..380 'Foo::b...32>(S)': u32
1046             378..379 'S': S
1047             386..408 '<F as ...:<u32>': fn bar<F, u32>(S) -> u32
1048             386..411 '<F as ...32>(S)': u32
1049             409..410 'S': S
1050             418..421 'foo': fn foo<{unknown}>(S) -> {unknown}
1051             418..424 'foo(S)': {unknown}
1052             422..423 'S': S
1053             430..440 'foo::<u32>': fn foo<u32>(S) -> u32
1054             430..443 'foo::<u32>(S)': u32
1055             441..442 'S': S
1056             449..464 'foo::<u32, i32>': fn foo<u32>(S) -> u32
1057             449..467 'foo::<...32>(S)': u32
1058             465..466 'S': S
1059         "#]],
1060     );
1061 }
1062
1063 #[test]
1064 fn argument_impl_trait_type_args_2() {
1065     check_infer_with_mismatches(
1066         r#"
1067 trait Trait {}
1068 struct S;
1069 impl Trait for S {}
1070 struct F<T>;
1071 impl<T> F<T> {
1072     fn foo<U>(self, x: impl Trait) -> (T, U) { loop {} }
1073 }
1074
1075 fn test() {
1076     F.foo(S);
1077     F::<u32>.foo(S);
1078     F::<u32>.foo::<i32>(S);
1079     F::<u32>.foo::<i32, u32>(S); // extraneous argument should be ignored
1080 }"#,
1081         expect![[r#"
1082             87..91 'self': F<T>
1083             93..94 'x': impl Trait
1084             118..129 '{ loop {} }': (T, U)
1085             120..127 'loop {}': !
1086             125..127 '{}': ()
1087             143..283 '{     ...ored }': ()
1088             149..150 'F': F<{unknown}>
1089             149..157 'F.foo(S)': ({unknown}, {unknown})
1090             155..156 'S': S
1091             163..171 'F::<u32>': F<u32>
1092             163..178 'F::<u32>.foo(S)': (u32, {unknown})
1093             176..177 'S': S
1094             184..192 'F::<u32>': F<u32>
1095             184..206 'F::<u3...32>(S)': (u32, i32)
1096             204..205 'S': S
1097             212..220 'F::<u32>': F<u32>
1098             212..239 'F::<u3...32>(S)': (u32, i32)
1099             237..238 'S': S
1100         "#]],
1101     );
1102 }
1103
1104 #[test]
1105 fn argument_impl_trait_to_fn_pointer() {
1106     check_infer_with_mismatches(
1107         r#"
1108 trait Trait {}
1109 fn foo(x: impl Trait) { loop {} }
1110 struct S;
1111 impl Trait for S {}
1112
1113 fn test() {
1114     let f: fn(S) -> () = foo;
1115 }"#,
1116         expect![[r#"
1117             22..23 'x': impl Trait
1118             37..48 '{ loop {} }': ()
1119             39..46 'loop {}': !
1120             44..46 '{}': ()
1121             90..123 '{     ...foo; }': ()
1122             100..101 'f': fn(S)
1123             117..120 'foo': fn foo(S)
1124         "#]],
1125     );
1126 }
1127
1128 #[test]
1129 fn impl_trait() {
1130     check_infer(
1131         r#"
1132 trait Trait<T> {
1133     fn foo(&self) -> T;
1134     fn foo2(&self) -> i64;
1135 }
1136 fn bar() -> impl Trait<u64> {}
1137
1138 fn test(x: impl Trait<u64>, y: &impl Trait<u64>) {
1139     x;
1140     y;
1141     let z = bar();
1142     x.foo();
1143     y.foo();
1144     z.foo();
1145     x.foo2();
1146     y.foo2();
1147     z.foo2();
1148 }"#,
1149         expect![[r#"
1150             29..33 'self': &Self
1151             54..58 'self': &Self
1152             98..100 '{}': ()
1153             110..111 'x': impl Trait<u64>
1154             130..131 'y': &impl Trait<u64>
1155             151..268 '{     ...2(); }': ()
1156             157..158 'x': impl Trait<u64>
1157             164..165 'y': &impl Trait<u64>
1158             175..176 'z': impl Trait<u64>
1159             179..182 'bar': fn bar() -> impl Trait<u64>
1160             179..184 'bar()': impl Trait<u64>
1161             190..191 'x': impl Trait<u64>
1162             190..197 'x.foo()': u64
1163             203..204 'y': &impl Trait<u64>
1164             203..210 'y.foo()': u64
1165             216..217 'z': impl Trait<u64>
1166             216..223 'z.foo()': u64
1167             229..230 'x': impl Trait<u64>
1168             229..237 'x.foo2()': i64
1169             243..244 'y': &impl Trait<u64>
1170             243..251 'y.foo2()': i64
1171             257..258 'z': impl Trait<u64>
1172             257..265 'z.foo2()': i64
1173         "#]],
1174     );
1175 }
1176
1177 #[test]
1178 fn simple_return_pos_impl_trait() {
1179     cov_mark::check!(lower_rpit);
1180     check_infer(
1181         r#"
1182 trait Trait<T> {
1183     fn foo(&self) -> T;
1184 }
1185 fn bar() -> impl Trait<u64> { loop {} }
1186
1187 fn test() {
1188     let a = bar();
1189     a.foo();
1190 }"#,
1191         expect![[r#"
1192             29..33 'self': &Self
1193             71..82 '{ loop {} }': !
1194             73..80 'loop {}': !
1195             78..80 '{}': ()
1196             94..129 '{     ...o(); }': ()
1197             104..105 'a': impl Trait<u64>
1198             108..111 'bar': fn bar() -> impl Trait<u64>
1199             108..113 'bar()': impl Trait<u64>
1200             119..120 'a': impl Trait<u64>
1201             119..126 'a.foo()': u64
1202         "#]],
1203     );
1204 }
1205
1206 #[test]
1207 fn more_return_pos_impl_trait() {
1208     check_infer(
1209         r#"
1210 trait Iterator {
1211     type Item;
1212     fn next(&mut self) -> Self::Item;
1213 }
1214 trait Trait<T> {
1215     fn foo(&self) -> T;
1216 }
1217 fn bar() -> (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>) { loop {} }
1218 fn baz<T>(t: T) -> (impl Iterator<Item = impl Trait<T>>, impl Trait<T>) { loop {} }
1219
1220 fn test() {
1221     let (a, b) = bar();
1222     a.next().foo();
1223     b.foo();
1224     let (c, d) = baz(1u128);
1225     c.next().foo();
1226     d.foo();
1227 }"#,
1228         expect![[r#"
1229             49..53 'self': &mut Self
1230             101..105 'self': &Self
1231             184..195 '{ loop {} }': ({unknown}, {unknown})
1232             186..193 'loop {}': !
1233             191..193 '{}': ()
1234             206..207 't': T
1235             268..279 '{ loop {} }': ({unknown}, {unknown})
1236             270..277 'loop {}': !
1237             275..277 '{}': ()
1238             291..413 '{     ...o(); }': ()
1239             301..307 '(a, b)': (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>)
1240             302..303 'a': impl Iterator<Item = impl Trait<u32>>
1241             305..306 'b': impl Trait<u64>
1242             310..313 'bar': fn bar() -> (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>)
1243             310..315 'bar()': (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>)
1244             321..322 'a': impl Iterator<Item = impl Trait<u32>>
1245             321..329 'a.next()': impl Trait<u32>
1246             321..335 'a.next().foo()': u32
1247             341..342 'b': impl Trait<u64>
1248             341..348 'b.foo()': u64
1249             358..364 '(c, d)': (impl Iterator<Item = impl Trait<u128>>, impl Trait<u128>)
1250             359..360 'c': impl Iterator<Item = impl Trait<u128>>
1251             362..363 'd': impl Trait<u128>
1252             367..370 'baz': fn baz<u128>(u128) -> (impl Iterator<Item = impl Trait<u128>>, impl Trait<u128>)
1253             367..377 'baz(1u128)': (impl Iterator<Item = impl Trait<u128>>, impl Trait<u128>)
1254             371..376 '1u128': u128
1255             383..384 'c': impl Iterator<Item = impl Trait<u128>>
1256             383..391 'c.next()': impl Trait<u128>
1257             383..397 'c.next().foo()': u128
1258             403..404 'd': impl Trait<u128>
1259             403..410 'd.foo()': u128
1260         "#]],
1261     );
1262 }
1263
1264 #[test]
1265 fn dyn_trait() {
1266     check_infer(
1267         r#"
1268 trait Trait<T> {
1269     fn foo(&self) -> T;
1270     fn foo2(&self) -> i64;
1271 }
1272 fn bar() -> dyn Trait<u64> {}
1273
1274 fn test(x: dyn Trait<u64>, y: &dyn Trait<u64>) {
1275     x;
1276     y;
1277     let z = bar();
1278     x.foo();
1279     y.foo();
1280     z.foo();
1281     x.foo2();
1282     y.foo2();
1283     z.foo2();
1284 }"#,
1285         expect![[r#"
1286             29..33 'self': &Self
1287             54..58 'self': &Self
1288             97..99 '{}': ()
1289             109..110 'x': dyn Trait<u64>
1290             128..129 'y': &dyn Trait<u64>
1291             148..265 '{     ...2(); }': ()
1292             154..155 'x': dyn Trait<u64>
1293             161..162 'y': &dyn Trait<u64>
1294             172..173 'z': dyn Trait<u64>
1295             176..179 'bar': fn bar() -> dyn Trait<u64>
1296             176..181 'bar()': dyn Trait<u64>
1297             187..188 'x': dyn Trait<u64>
1298             187..194 'x.foo()': u64
1299             200..201 'y': &dyn Trait<u64>
1300             200..207 'y.foo()': u64
1301             213..214 'z': dyn Trait<u64>
1302             213..220 'z.foo()': u64
1303             226..227 'x': dyn Trait<u64>
1304             226..234 'x.foo2()': i64
1305             240..241 'y': &dyn Trait<u64>
1306             240..248 'y.foo2()': i64
1307             254..255 'z': dyn Trait<u64>
1308             254..262 'z.foo2()': i64
1309         "#]],
1310     );
1311 }
1312
1313 #[test]
1314 fn dyn_trait_in_impl() {
1315     check_infer(
1316         r#"
1317 trait Trait<T, U> {
1318     fn foo(&self) -> (T, U);
1319 }
1320 struct S<T, U> {}
1321 impl<T, U> S<T, U> {
1322     fn bar(&self) -> &dyn Trait<T, U> { loop {} }
1323 }
1324 trait Trait2<T, U> {
1325     fn baz(&self) -> (T, U);
1326 }
1327 impl<T, U> Trait2<T, U> for dyn Trait<T, U> { }
1328
1329 fn test(s: S<u32, i32>) {
1330     s.bar().baz();
1331 }"#,
1332         expect![[r#"
1333             32..36 'self': &Self
1334             102..106 'self': &S<T, U>
1335             128..139 '{ loop {} }': &dyn Trait<T, U>
1336             130..137 'loop {}': !
1337             135..137 '{}': ()
1338             175..179 'self': &Self
1339             251..252 's': S<u32, i32>
1340             267..289 '{     ...z(); }': ()
1341             273..274 's': S<u32, i32>
1342             273..280 's.bar()': &dyn Trait<u32, i32>
1343             273..286 's.bar().baz()': (u32, i32)
1344         "#]],
1345     );
1346 }
1347
1348 #[test]
1349 fn dyn_trait_bare() {
1350     check_infer(
1351         r#"
1352 trait Trait {
1353     fn foo(&self) -> u64;
1354 }
1355 fn bar() -> Trait {}
1356
1357 fn test(x: Trait, y: &Trait) -> u64 {
1358     x;
1359     y;
1360     let z = bar();
1361     x.foo();
1362     y.foo();
1363     z.foo();
1364 }"#,
1365         expect![[r#"
1366             26..30 'self': &Self
1367             60..62 '{}': ()
1368             72..73 'x': dyn Trait
1369             82..83 'y': &dyn Trait
1370             100..175 '{     ...o(); }': ()
1371             106..107 'x': dyn Trait
1372             113..114 'y': &dyn Trait
1373             124..125 'z': dyn Trait
1374             128..131 'bar': fn bar() -> dyn Trait
1375             128..133 'bar()': dyn Trait
1376             139..140 'x': dyn Trait
1377             139..146 'x.foo()': u64
1378             152..153 'y': &dyn Trait
1379             152..159 'y.foo()': u64
1380             165..166 'z': dyn Trait
1381             165..172 'z.foo()': u64
1382         "#]],
1383     );
1384 }
1385
1386 #[test]
1387 fn weird_bounds() {
1388     check_infer(
1389         r#"
1390 trait Trait {}
1391 fn test(
1392     a: impl Trait + 'lifetime,
1393     b: impl 'lifetime,
1394     c: impl (Trait),
1395     d: impl ('lifetime),
1396     e: impl ?Sized,
1397     f: impl Trait + ?Sized
1398 ) {}
1399 "#,
1400         expect![[r#"
1401             28..29 'a': impl Trait
1402             59..60 'b': impl
1403             82..83 'c': impl Trait
1404             103..104 'd': impl
1405             128..129 'e': impl
1406             148..149 'f': impl Trait
1407             173..175 '{}': ()
1408         "#]],
1409     );
1410 }
1411
1412 #[test]
1413 fn error_bound_chalk() {
1414     check_types(
1415         r#"
1416 trait Trait {
1417     fn foo(&self) -> u32 {}
1418 }
1419
1420 fn test(x: (impl Trait + UnknownTrait)) {
1421     x.foo();
1422 }       //^ u32
1423 "#,
1424     );
1425 }
1426
1427 #[test]
1428 fn assoc_type_bindings() {
1429     check_infer(
1430         r#"
1431 trait Trait {
1432     type Type;
1433 }
1434
1435 fn get<T: Trait>(t: T) -> <T as Trait>::Type {}
1436 fn get2<U, T: Trait<Type = U>>(t: T) -> U {}
1437 fn set<T: Trait<Type = u64>>(t: T) -> T {t}
1438
1439 struct S<T>;
1440 impl<T> Trait for S<T> { type Type = T; }
1441
1442 fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
1443     get(x);
1444     get2(x);
1445     get(y);
1446     get2(y);
1447     get(set(S));
1448     get2(set(S));
1449     get2(S::<str>);
1450 }"#,
1451         expect![[r#"
1452             49..50 't': T
1453             77..79 '{}': ()
1454             111..112 't': T
1455             122..124 '{}': ()
1456             154..155 't': T
1457             165..168 '{t}': T
1458             166..167 't': T
1459             256..257 'x': T
1460             262..263 'y': impl Trait<Type = i64>
1461             289..397 '{     ...r>); }': ()
1462             295..298 'get': fn get<T>(T) -> <T as Trait>::Type
1463             295..301 'get(x)': u32
1464             299..300 'x': T
1465             307..311 'get2': fn get2<u32, T>(T) -> u32
1466             307..314 'get2(x)': u32
1467             312..313 'x': T
1468             320..323 'get': fn get<impl Trait<Type = i64>>(impl Trait<Type = i64>) -> <impl Trait<Type = i64> as Trait>::Type
1469             320..326 'get(y)': i64
1470             324..325 'y': impl Trait<Type = i64>
1471             332..336 'get2': fn get2<i64, impl Trait<Type = i64>>(impl Trait<Type = i64>) -> i64
1472             332..339 'get2(y)': i64
1473             337..338 'y': impl Trait<Type = i64>
1474             345..348 'get': fn get<S<u64>>(S<u64>) -> <S<u64> as Trait>::Type
1475             345..356 'get(set(S))': u64
1476             349..352 'set': fn set<S<u64>>(S<u64>) -> S<u64>
1477             349..355 'set(S)': S<u64>
1478             353..354 'S': S<u64>
1479             362..366 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
1480             362..374 'get2(set(S))': u64
1481             367..370 'set': fn set<S<u64>>(S<u64>) -> S<u64>
1482             367..373 'set(S)': S<u64>
1483             371..372 'S': S<u64>
1484             380..384 'get2': fn get2<str, S<str>>(S<str>) -> str
1485             380..394 'get2(S::<str>)': str
1486             385..393 'S::<str>': S<str>
1487         "#]],
1488     );
1489 }
1490
1491 #[test]
1492 fn impl_trait_assoc_binding_projection_bug() {
1493     check_types(
1494         r#"
1495 //- /main.rs crate:main deps:std
1496 pub trait Language {
1497     type Kind;
1498 }
1499 pub enum RustLanguage {}
1500 impl Language for RustLanguage {
1501     type Kind = SyntaxKind;
1502 }
1503 struct SyntaxNode<L> {}
1504 fn foo() -> impl Iterator<Item = SyntaxNode<RustLanguage>> {}
1505
1506 trait Clone {
1507     fn clone(&self) -> Self;
1508 }
1509
1510 fn api_walkthrough() {
1511     for node in foo() {
1512         node.clone();
1513     }            //^ {unknown}
1514 }
1515
1516 //- /std.rs crate:std
1517 #[prelude_import] use iter::*;
1518 mod iter {
1519     trait IntoIterator {
1520         type Item;
1521     }
1522     trait Iterator {
1523         type Item;
1524     }
1525     impl<T: Iterator> IntoIterator for T {
1526         type Item = <T as Iterator>::Item;
1527     }
1528 }
1529 "#,
1530     );
1531 }
1532
1533 #[test]
1534 fn projection_eq_within_chalk() {
1535     check_infer(
1536         r#"
1537 trait Trait1 {
1538     type Type;
1539 }
1540 trait Trait2<T> {
1541     fn foo(self) -> T;
1542 }
1543 impl<T, U> Trait2<T> for U where U: Trait1<Type = T> {}
1544
1545 fn test<T: Trait1<Type = u32>>(x: T) {
1546     x.foo();
1547 }"#,
1548         expect![[r#"
1549             61..65 'self': Self
1550             163..164 'x': T
1551             169..185 '{     ...o(); }': ()
1552             175..176 'x': T
1553             175..182 'x.foo()': u32
1554         "#]],
1555     );
1556 }
1557
1558 #[test]
1559 fn where_clause_trait_in_scope_for_method_resolution() {
1560     check_types(
1561         r#"
1562 mod foo {
1563     trait Trait {
1564         fn foo(&self) -> u32 {}
1565     }
1566 }
1567
1568 fn test<T: foo::Trait>(x: T) {
1569     x.foo();
1570 }      //^ u32
1571 "#,
1572     );
1573 }
1574
1575 #[test]
1576 fn super_trait_method_resolution() {
1577     check_infer(
1578         r#"
1579 mod foo {
1580     trait SuperTrait {
1581         fn foo(&self) -> u32 {}
1582     }
1583 }
1584 trait Trait1: foo::SuperTrait {}
1585 trait Trait2 where Self: foo::SuperTrait {}
1586
1587 fn test<T: Trait1, U: Trait2>(x: T, y: U) {
1588     x.foo();
1589     y.foo();
1590 }"#,
1591         expect![[r#"
1592             49..53 'self': &Self
1593             62..64 '{}': ()
1594             181..182 'x': T
1595             187..188 'y': U
1596             193..222 '{     ...o(); }': ()
1597             199..200 'x': T
1598             199..206 'x.foo()': u32
1599             212..213 'y': U
1600             212..219 'y.foo()': u32
1601         "#]],
1602     );
1603 }
1604
1605 #[test]
1606 fn super_trait_impl_trait_method_resolution() {
1607     check_infer(
1608         r#"
1609 mod foo {
1610     trait SuperTrait {
1611         fn foo(&self) -> u32 {}
1612     }
1613 }
1614 trait Trait1: foo::SuperTrait {}
1615
1616 fn test(x: &impl Trait1) {
1617     x.foo();
1618 }"#,
1619         expect![[r#"
1620             49..53 'self': &Self
1621             62..64 '{}': ()
1622             115..116 'x': &impl Trait1
1623             132..148 '{     ...o(); }': ()
1624             138..139 'x': &impl Trait1
1625             138..145 'x.foo()': u32
1626         "#]],
1627     );
1628 }
1629
1630 #[test]
1631 fn super_trait_cycle() {
1632     // This just needs to not crash
1633     check_infer(
1634         r#"
1635         trait A: B {}
1636         trait B: A {}
1637
1638         fn test<T: A>(x: T) {
1639             x.foo();
1640         }
1641         "#,
1642         expect![[r#"
1643             43..44 'x': T
1644             49..65 '{     ...o(); }': ()
1645             55..56 'x': T
1646             55..62 'x.foo()': {unknown}
1647         "#]],
1648     );
1649 }
1650
1651 #[test]
1652 fn super_trait_assoc_type_bounds() {
1653     check_infer(
1654         r#"
1655 trait SuperTrait { type Type; }
1656 trait Trait where Self: SuperTrait {}
1657
1658 fn get2<U, T: Trait<Type = U>>(t: T) -> U {}
1659 fn set<T: Trait<Type = u64>>(t: T) -> T {t}
1660
1661 struct S<T>;
1662 impl<T> SuperTrait for S<T> { type Type = T; }
1663 impl<T> Trait for S<T> {}
1664
1665 fn test() {
1666     get2(set(S));
1667 }"#,
1668         expect![[r#"
1669             102..103 't': T
1670             113..115 '{}': ()
1671             145..146 't': T
1672             156..159 '{t}': T
1673             157..158 't': T
1674             258..279 '{     ...S)); }': ()
1675             264..268 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
1676             264..276 'get2(set(S))': u64
1677             269..272 'set': fn set<S<u64>>(S<u64>) -> S<u64>
1678             269..275 'set(S)': S<u64>
1679             273..274 'S': S<u64>
1680         "#]],
1681     );
1682 }
1683
1684 #[test]
1685 fn fn_trait() {
1686     check_infer_with_mismatches(
1687         r#"
1688 trait FnOnce<Args> {
1689     type Output;
1690
1691     fn call_once(self, args: Args) -> <Self as FnOnce<Args>>::Output;
1692 }
1693
1694 fn test<F: FnOnce(u32, u64) -> u128>(f: F) {
1695     f.call_once((1, 2));
1696 }"#,
1697         expect![[r#"
1698             56..60 'self': Self
1699             62..66 'args': Args
1700             149..150 'f': F
1701             155..183 '{     ...2)); }': ()
1702             161..162 'f': F
1703             161..180 'f.call...1, 2))': u128
1704             173..179 '(1, 2)': (u32, u64)
1705             174..175 '1': u32
1706             177..178 '2': u64
1707         "#]],
1708     );
1709 }
1710
1711 #[test]
1712 fn fn_ptr_and_item() {
1713     check_infer_with_mismatches(
1714         r#"
1715 #[lang="fn_once"]
1716 trait FnOnce<Args> {
1717     type Output;
1718
1719     fn call_once(self, args: Args) -> Self::Output;
1720 }
1721
1722 trait Foo<T> {
1723     fn foo(&self) -> T;
1724 }
1725
1726 struct Bar<T>(T);
1727
1728 impl<A1, R, F: FnOnce(A1) -> R> Foo<(A1, R)> for Bar<F> {
1729     fn foo(&self) -> (A1, R) { loop {} }
1730 }
1731
1732 enum Opt<T> { None, Some(T) }
1733 impl<T> Opt<T> {
1734     fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Opt<U> { loop {} }
1735 }
1736
1737 fn test() {
1738     let bar: Bar<fn(u8) -> u32>;
1739     bar.foo();
1740
1741     let opt: Opt<u8>;
1742     let f: fn(u8) -> u32;
1743     opt.map(f);
1744 }"#,
1745         expect![[r#"
1746             74..78 'self': Self
1747             80..84 'args': Args
1748             139..143 'self': &Self
1749             243..247 'self': &Bar<F>
1750             260..271 '{ loop {} }': (A1, R)
1751             262..269 'loop {}': !
1752             267..269 '{}': ()
1753             355..359 'self': Opt<T>
1754             361..362 'f': F
1755             377..388 '{ loop {} }': Opt<U>
1756             379..386 'loop {}': !
1757             384..386 '{}': ()
1758             402..518 '{     ...(f); }': ()
1759             412..415 'bar': Bar<fn(u8) -> u32>
1760             441..444 'bar': Bar<fn(u8) -> u32>
1761             441..450 'bar.foo()': (u8, u32)
1762             461..464 'opt': Opt<u8>
1763             483..484 'f': fn(u8) -> u32
1764             505..508 'opt': Opt<u8>
1765             505..515 'opt.map(f)': Opt<u32>
1766             513..514 'f': fn(u8) -> u32
1767         "#]],
1768     );
1769 }
1770
1771 #[test]
1772 fn fn_trait_deref_with_ty_default() {
1773     check_infer(
1774         r#"
1775 #[lang = "deref"]
1776 trait Deref {
1777     type Target;
1778
1779     fn deref(&self) -> &Self::Target;
1780 }
1781
1782 #[lang="fn_once"]
1783 trait FnOnce<Args> {
1784     type Output;
1785
1786     fn call_once(self, args: Args) -> Self::Output;
1787 }
1788
1789 struct Foo;
1790
1791 impl Foo {
1792     fn foo(&self) -> usize {}
1793 }
1794
1795 struct Lazy<T, F = fn() -> T>(F);
1796
1797 impl<T, F> Lazy<T, F> {
1798     pub fn new(f: F) -> Lazy<T, F> {}
1799 }
1800
1801 impl<T, F: FnOnce() -> T> Deref for Lazy<T, F> {
1802     type Target = T;
1803 }
1804
1805 fn test() {
1806     let lazy1: Lazy<Foo, _> = Lazy::new(|| Foo);
1807     let r1 = lazy1.foo();
1808
1809     fn make_foo_fn() -> Foo {}
1810     let make_foo_fn_ptr: fn() -> Foo = make_foo_fn;
1811     let lazy2: Lazy<Foo, _> = Lazy::new(make_foo_fn_ptr);
1812     let r2 = lazy2.foo();
1813 }"#,
1814         expect![[r#"
1815             64..68 'self': &Self
1816             165..169 'self': Self
1817             171..175 'args': Args
1818             239..243 'self': &Foo
1819             254..256 '{}': ()
1820             334..335 'f': F
1821             354..356 '{}': ()
1822             443..689 '{     ...o(); }': ()
1823             453..458 'lazy1': Lazy<Foo, || -> Foo>
1824             475..484 'Lazy::new': fn new<Foo, || -> Foo>(|| -> Foo) -> Lazy<Foo, || -> Foo>
1825             475..492 'Lazy::...| Foo)': Lazy<Foo, || -> Foo>
1826             485..491 '|| Foo': || -> Foo
1827             488..491 'Foo': Foo
1828             502..504 'r1': usize
1829             507..512 'lazy1': Lazy<Foo, || -> Foo>
1830             507..518 'lazy1.foo()': usize
1831             560..575 'make_foo_fn_ptr': fn() -> Foo
1832             591..602 'make_foo_fn': fn make_foo_fn() -> Foo
1833             612..617 'lazy2': Lazy<Foo, fn() -> Foo>
1834             634..643 'Lazy::new': fn new<Foo, fn() -> Foo>(fn() -> Foo) -> Lazy<Foo, fn() -> Foo>
1835             634..660 'Lazy::...n_ptr)': Lazy<Foo, fn() -> Foo>
1836             644..659 'make_foo_fn_ptr': fn() -> Foo
1837             670..672 'r2': usize
1838             675..680 'lazy2': Lazy<Foo, fn() -> Foo>
1839             675..686 'lazy2.foo()': usize
1840             549..551 '{}': ()
1841         "#]],
1842     );
1843 }
1844
1845 #[test]
1846 fn closure_1() {
1847     check_infer_with_mismatches(
1848         r#"
1849 #[lang = "fn_once"]
1850 trait FnOnce<Args> {
1851     type Output;
1852 }
1853
1854 enum Option<T> { Some(T), None }
1855 impl<T> Option<T> {
1856     fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Option<U> { loop {} }
1857 }
1858
1859 fn test() {
1860     let x = Option::Some(1u32);
1861     x.map(|v| v + 1);
1862     x.map(|_v| 1u64);
1863     let y: Option<i64> = x.map(|_v| 1);
1864 }"#,
1865         expect![[r#"
1866             147..151 'self': Option<T>
1867             153..154 'f': F
1868             172..183 '{ loop {} }': Option<U>
1869             174..181 'loop {}': !
1870             179..181 '{}': ()
1871             197..316 '{     ... 1); }': ()
1872             207..208 'x': Option<u32>
1873             211..223 'Option::Some': Some<u32>(u32) -> Option<u32>
1874             211..229 'Option...(1u32)': Option<u32>
1875             224..228 '1u32': u32
1876             235..236 'x': Option<u32>
1877             235..251 'x.map(...v + 1)': Option<u32>
1878             241..250 '|v| v + 1': |u32| -> u32
1879             242..243 'v': u32
1880             245..246 'v': u32
1881             245..250 'v + 1': u32
1882             249..250 '1': u32
1883             257..258 'x': Option<u32>
1884             257..273 'x.map(... 1u64)': Option<u64>
1885             263..272 '|_v| 1u64': |u32| -> u64
1886             264..266 '_v': u32
1887             268..272 '1u64': u64
1888             283..284 'y': Option<i64>
1889             300..301 'x': Option<u32>
1890             300..313 'x.map(|_v| 1)': Option<i64>
1891             306..312 '|_v| 1': |u32| -> i64
1892             307..309 '_v': u32
1893             311..312 '1': i64
1894         "#]],
1895     );
1896 }
1897
1898 #[test]
1899 fn closure_2() {
1900     check_infer_with_mismatches(
1901         r#"
1902 #[lang = "add"]
1903 pub trait Add<Rhs = Self> {
1904     type Output;
1905     fn add(self, rhs: Rhs) -> Self::Output;
1906 }
1907
1908 trait FnOnce<Args> {
1909     type Output;
1910 }
1911
1912 impl Add for u64 {
1913     type Output = Self;
1914     fn add(self, rhs: u64) -> Self::Output {0}
1915 }
1916
1917 impl Add for u128 {
1918     type Output = Self;
1919     fn add(self, rhs: u128) -> Self::Output {0}
1920 }
1921
1922 fn test<F: FnOnce(u32) -> u64>(f: F) {
1923     f(1);
1924     let g = |v| v + 1;
1925     g(1u64);
1926     let h = |v| 1u128 + v;
1927 }"#,
1928         expect![[r#"
1929             72..76 'self': Self
1930             78..81 'rhs': Rhs
1931             203..207 'self': u64
1932             209..212 'rhs': u64
1933             235..238 '{0}': u64
1934             236..237 '0': u64
1935             297..301 'self': u128
1936             303..306 'rhs': u128
1937             330..333 '{0}': u128
1938             331..332 '0': u128
1939             368..369 'f': F
1940             374..450 '{     ...+ v; }': ()
1941             380..381 'f': F
1942             380..384 'f(1)': {unknown}
1943             382..383 '1': i32
1944             394..395 'g': |u64| -> u64
1945             398..407 '|v| v + 1': |u64| -> u64
1946             399..400 'v': u64
1947             402..403 'v': u64
1948             402..407 'v + 1': u64
1949             406..407 '1': u64
1950             413..414 'g': |u64| -> u64
1951             413..420 'g(1u64)': u64
1952             415..419 '1u64': u64
1953             430..431 'h': |u128| -> u128
1954             434..447 '|v| 1u128 + v': |u128| -> u128
1955             435..436 'v': u128
1956             438..443 '1u128': u128
1957             438..447 '1u128 + v': u128
1958             446..447 'v': u128
1959         "#]],
1960     );
1961 }
1962
1963 #[test]
1964 fn closure_as_argument_inference_order() {
1965     check_infer_with_mismatches(
1966         r#"
1967 #[lang = "fn_once"]
1968 trait FnOnce<Args> {
1969     type Output;
1970 }
1971
1972 fn foo1<T, U, F: FnOnce(T) -> U>(x: T, f: F) -> U { loop {} }
1973 fn foo2<T, U, F: FnOnce(T) -> U>(f: F, x: T) -> U { loop {} }
1974
1975 struct S;
1976 impl S {
1977     fn method(self) -> u64;
1978
1979     fn foo1<T, U, F: FnOnce(T) -> U>(self, x: T, f: F) -> U { loop {} }
1980     fn foo2<T, U, F: FnOnce(T) -> U>(self, f: F, x: T) -> U { loop {} }
1981 }
1982
1983 fn test() {
1984     let x1 = foo1(S, |s| s.method());
1985     let x2 = foo2(|s| s.method(), S);
1986     let x3 = S.foo1(S, |s| s.method());
1987     let x4 = S.foo2(|s| s.method(), S);
1988 }"#,
1989         expect![[r#"
1990             94..95 'x': T
1991             100..101 'f': F
1992             111..122 '{ loop {} }': U
1993             113..120 'loop {}': !
1994             118..120 '{}': ()
1995             156..157 'f': F
1996             162..163 'x': T
1997             173..184 '{ loop {} }': U
1998             175..182 'loop {}': !
1999             180..182 '{}': ()
2000             219..223 'self': S
2001             271..275 'self': S
2002             277..278 'x': T
2003             283..284 'f': F
2004             294..305 '{ loop {} }': U
2005             296..303 'loop {}': !
2006             301..303 '{}': ()
2007             343..347 'self': S
2008             349..350 'f': F
2009             355..356 'x': T
2010             366..377 '{ loop {} }': U
2011             368..375 'loop {}': !
2012             373..375 '{}': ()
2013             391..550 '{     ... S); }': ()
2014             401..403 'x1': u64
2015             406..410 'foo1': fn foo1<S, u64, |S| -> u64>(S, |S| -> u64) -> u64
2016             406..429 'foo1(S...hod())': u64
2017             411..412 'S': S
2018             414..428 '|s| s.method()': |S| -> u64
2019             415..416 's': S
2020             418..419 's': S
2021             418..428 's.method()': u64
2022             439..441 'x2': u64
2023             444..448 'foo2': fn foo2<S, u64, |S| -> u64>(|S| -> u64, S) -> u64
2024             444..467 'foo2(|...(), S)': u64
2025             449..463 '|s| s.method()': |S| -> u64
2026             450..451 's': S
2027             453..454 's': S
2028             453..463 's.method()': u64
2029             465..466 'S': S
2030             477..479 'x3': u64
2031             482..483 'S': S
2032             482..507 'S.foo1...hod())': u64
2033             489..490 'S': S
2034             492..506 '|s| s.method()': |S| -> u64
2035             493..494 's': S
2036             496..497 's': S
2037             496..506 's.method()': u64
2038             517..519 'x4': u64
2039             522..523 'S': S
2040             522..547 'S.foo2...(), S)': u64
2041             529..543 '|s| s.method()': |S| -> u64
2042             530..531 's': S
2043             533..534 's': S
2044             533..543 's.method()': u64
2045             545..546 'S': S
2046         "#]],
2047     );
2048 }
2049
2050 #[test]
2051 fn fn_item_fn_trait() {
2052     check_types(
2053         r#"
2054 #[lang = "fn_once"]
2055 trait FnOnce<Args> {
2056     type Output;
2057 }
2058
2059 struct S;
2060
2061 fn foo() -> S {}
2062
2063 fn takes_closure<U, F: FnOnce() -> U>(f: F) -> U { f() }
2064
2065 fn test() {
2066     takes_closure(foo);
2067 } //^^^^^^^^^^^^^^^^^^ S
2068 "#,
2069     );
2070 }
2071
2072 #[test]
2073 fn unselected_projection_in_trait_env_1() {
2074     check_types(
2075         r#"
2076 //- /main.rs
2077 trait Trait {
2078     type Item;
2079 }
2080
2081 trait Trait2 {
2082     fn foo(&self) -> u32;
2083 }
2084
2085 fn test<T: Trait>() where T::Item: Trait2 {
2086     let x: T::Item = no_matter;
2087     x.foo();
2088 }       //^ u32
2089 "#,
2090     );
2091 }
2092
2093 #[test]
2094 fn unselected_projection_in_trait_env_2() {
2095     check_types(
2096         r#"
2097 trait Trait<T> {
2098     type Item;
2099 }
2100
2101 trait Trait2 {
2102     fn foo(&self) -> u32;
2103 }
2104
2105 fn test<T, U>() where T::Item: Trait2, T: Trait<U::Item>, U: Trait<()> {
2106     let x: T::Item = no_matter;
2107     x.foo();
2108 }       //^ u32
2109 "#,
2110     );
2111 }
2112
2113 #[test]
2114 fn unselected_projection_on_impl_self() {
2115     check_infer(
2116         r#"
2117 //- /main.rs
2118 trait Trait {
2119     type Item;
2120
2121     fn f(&self, x: Self::Item);
2122 }
2123
2124 struct S;
2125
2126 impl Trait for S {
2127     type Item = u32;
2128     fn f(&self, x: Self::Item) { let y = x; }
2129 }
2130
2131 struct S2;
2132
2133 impl Trait for S2 {
2134     type Item = i32;
2135     fn f(&self, x: <Self>::Item) { let y = x; }
2136 }"#,
2137         expect![[r#"
2138             40..44 'self': &Self
2139             46..47 'x': Trait::Item<Self>
2140             126..130 'self': &S
2141             132..133 'x': u32
2142             147..161 '{ let y = x; }': ()
2143             153..154 'y': u32
2144             157..158 'x': u32
2145             228..232 'self': &S2
2146             234..235 'x': i32
2147             251..265 '{ let y = x; }': ()
2148             257..258 'y': i32
2149             261..262 'x': i32
2150         "#]],
2151     );
2152 }
2153
2154 #[test]
2155 fn unselected_projection_on_trait_self() {
2156     check_types(
2157         r#"
2158 trait Trait {
2159     type Item;
2160
2161     fn f(&self) -> Self::Item { loop {} }
2162 }
2163
2164 struct S;
2165 impl Trait for S {
2166     type Item = u32;
2167 }
2168
2169 fn test() {
2170     S.f();
2171 }     //^ u32
2172 "#,
2173     );
2174 }
2175
2176 #[test]
2177 fn unselected_projection_chalk_fold() {
2178     check_types(
2179         r#"
2180 trait Interner {}
2181 trait Fold<I: Interner, TI = I> {
2182     type Result;
2183 }
2184
2185 struct Ty<I: Interner> {}
2186 impl<I: Interner, TI: Interner> Fold<I, TI> for Ty<I> {
2187     type Result = Ty<TI>;
2188 }
2189
2190 fn fold<I: Interner, T>(interner: &I, t: T) -> T::Result
2191 where
2192     T: Fold<I, I>,
2193 {
2194     loop {}
2195 }
2196
2197 fn foo<I: Interner>(interner: &I, t: Ty<I>) {
2198     fold(interner, t);
2199 }     //^ Ty<I>
2200 "#,
2201     );
2202 }
2203
2204 #[test]
2205 fn trait_impl_self_ty() {
2206     check_types(
2207         r#"
2208 trait Trait<T> {
2209    fn foo(&self);
2210 }
2211
2212 struct S;
2213
2214 impl Trait<Self> for S {}
2215
2216 fn test() {
2217     S.foo();
2218 }       //^ ()
2219 "#,
2220     );
2221 }
2222
2223 #[test]
2224 fn trait_impl_self_ty_cycle() {
2225     check_types(
2226         r#"
2227 trait Trait {
2228    fn foo(&self);
2229 }
2230
2231 struct S<T>;
2232
2233 impl Trait for S<Self> {}
2234
2235 fn test() {
2236     S.foo();
2237 }       //^ {unknown}
2238 "#,
2239     );
2240 }
2241
2242 #[test]
2243 fn unselected_projection_in_trait_env_cycle_1() {
2244     // this is a legitimate cycle
2245     check_types(
2246         r#"
2247 trait Trait {
2248     type Item;
2249 }
2250
2251 trait Trait2<T> {}
2252
2253 fn test<T: Trait>() where T: Trait2<T::Item> {
2254     let x: T::Item = no_matter;
2255 }                       //^ {unknown}
2256 "#,
2257     );
2258 }
2259
2260 #[test]
2261 fn unselected_projection_in_trait_env_cycle_2() {
2262     // this is a legitimate cycle
2263     check_types(
2264         r#"
2265 //- /main.rs
2266 trait Trait<T> {
2267     type Item;
2268 }
2269
2270 fn test<T, U>() where T: Trait<U::Item>, U: Trait<T::Item> {
2271     let x: T::Item = no_matter;
2272 }                   //^ {unknown}
2273 "#,
2274     );
2275 }
2276
2277 #[test]
2278 fn unselected_projection_in_trait_env_cycle_3() {
2279     // this is a cycle for rustc; we currently accept it
2280     check_types(
2281         r#"
2282 //- /main.rs
2283 trait Trait {
2284     type Item;
2285     type OtherItem;
2286 }
2287
2288 fn test<T>() where T: Trait<OtherItem = T::Item> {
2289     let x: T::Item = no_matter;
2290 }                   //^ Trait::Item<T>
2291 "#,
2292     );
2293 }
2294
2295 #[test]
2296 fn unselected_projection_in_trait_env_no_cycle() {
2297     // this is not a cycle
2298     check_types(
2299         r#"
2300 //- /main.rs
2301 trait Index {
2302     type Output;
2303 }
2304
2305 type Key<S: UnificationStoreBase> = <S as UnificationStoreBase>::Key;
2306
2307 pub trait UnificationStoreBase: Index<Output = Key<Self>> {
2308     type Key;
2309
2310     fn len(&self) -> usize;
2311 }
2312
2313 pub trait UnificationStoreMut: UnificationStoreBase {
2314     fn push(&mut self, value: Self::Key);
2315 }
2316
2317 fn test<T>(t: T) where T: UnificationStoreMut {
2318     let x;
2319     t.push(x);
2320     let y: Key<T>;
2321     (x, y);
2322 }      //^ (UnificationStoreBase::Key<T>, UnificationStoreBase::Key<T>)
2323 "#,
2324     );
2325 }
2326
2327 #[test]
2328 fn inline_assoc_type_bounds_1() {
2329     check_types(
2330         r#"
2331 trait Iterator {
2332     type Item;
2333 }
2334 trait OtherTrait<T> {
2335     fn foo(&self) -> T;
2336 }
2337
2338 // workaround for Chalk assoc type normalization problems
2339 pub struct S<T>;
2340 impl<T: Iterator> Iterator for S<T> {
2341     type Item = <T as Iterator>::Item;
2342 }
2343
2344 fn test<I: Iterator<Item: OtherTrait<u32>>>() {
2345     let x: <S<I> as Iterator>::Item;
2346     x.foo();
2347 }       //^ u32
2348 "#,
2349     );
2350 }
2351
2352 #[test]
2353 fn inline_assoc_type_bounds_2() {
2354     check_types(
2355         r#"
2356 trait Iterator {
2357     type Item;
2358 }
2359
2360 fn test<I: Iterator<Item: Iterator<Item = u32>>>() {
2361     let x: <<I as Iterator>::Item as Iterator>::Item;
2362     x;
2363 } //^ u32
2364 "#,
2365     );
2366 }
2367
2368 #[test]
2369 fn proc_macro_server_types() {
2370     check_infer(
2371         r#"
2372 macro_rules! with_api {
2373     ($S:ident, $self:ident, $m:ident) => {
2374         $m! {
2375             TokenStream {
2376                 fn new() -> $S::TokenStream;
2377             },
2378             Group {
2379             },
2380         }
2381     };
2382 }
2383 macro_rules! associated_item {
2384     (type TokenStream) =>
2385         (type TokenStream: 'static;);
2386     (type Group) =>
2387         (type Group: 'static;);
2388     ($($item:tt)*) => ($($item)*;)
2389 }
2390 macro_rules! declare_server_traits {
2391     ($($name:ident {
2392         $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)?;)*
2393     }),* $(,)?) => {
2394         pub trait Types {
2395             $(associated_item!(type $name);)*
2396         }
2397
2398         $(pub trait $name: Types {
2399             $(associated_item!(fn $method($($arg: $arg_ty),*) $(-> $ret_ty)?);)*
2400         })*
2401
2402         pub trait Server: Types $(+ $name)* {}
2403         impl<S: Types $(+ $name)*> Server for S {}
2404     }
2405 }
2406
2407 with_api!(Self, self_, declare_server_traits);
2408 struct G {}
2409 struct T {}
2410 struct Rustc;
2411 impl Types for Rustc {
2412     type TokenStream = T;
2413     type Group = G;
2414 }
2415
2416 fn make<T>() -> T { loop {} }
2417 impl TokenStream for Rustc {
2418     fn new() -> Self::TokenStream {
2419         let group: Self::Group = make();
2420         make()
2421     }
2422 }"#,
2423         expect![[r#"
2424             1061..1072 '{ loop {} }': T
2425             1063..1070 'loop {}': !
2426             1068..1070 '{}': ()
2427             1136..1199 '{     ...     }': T
2428             1150..1155 'group': G
2429             1171..1175 'make': fn make<G>() -> G
2430             1171..1177 'make()': G
2431             1187..1191 'make': fn make<T>() -> T
2432             1187..1193 'make()': T
2433         "#]],
2434     );
2435 }
2436
2437 #[test]
2438 fn unify_impl_trait() {
2439     check_infer_with_mismatches(
2440         r#"
2441 trait Trait<T> {}
2442
2443 fn foo(x: impl Trait<u32>) { loop {} }
2444 fn bar<T>(x: impl Trait<T>) -> T { loop {} }
2445
2446 struct S<T>(T);
2447 impl<T> Trait<T> for S<T> {}
2448
2449 fn default<T>() -> T { loop {} }
2450
2451 fn test() -> impl Trait<i32> {
2452     let s1 = S(default());
2453     foo(s1);
2454     let x: i32 = bar(S(default()));
2455     S(default())
2456 }"#,
2457         expect![[r#"
2458             26..27 'x': impl Trait<u32>
2459             46..57 '{ loop {} }': ()
2460             48..55 'loop {}': !
2461             53..55 '{}': ()
2462             68..69 'x': impl Trait<T>
2463             91..102 '{ loop {} }': T
2464             93..100 'loop {}': !
2465             98..100 '{}': ()
2466             171..182 '{ loop {} }': T
2467             173..180 'loop {}': !
2468             178..180 '{}': ()
2469             213..309 '{     ...t()) }': S<{unknown}>
2470             223..225 's1': S<u32>
2471             228..229 'S': S<u32>(u32) -> S<u32>
2472             228..240 'S(default())': S<u32>
2473             230..237 'default': fn default<u32>() -> u32
2474             230..239 'default()': u32
2475             246..249 'foo': fn foo(S<u32>)
2476             246..253 'foo(s1)': ()
2477             250..252 's1': S<u32>
2478             263..264 'x': i32
2479             272..275 'bar': fn bar<i32>(S<i32>) -> i32
2480             272..289 'bar(S(...lt()))': i32
2481             276..277 'S': S<i32>(i32) -> S<i32>
2482             276..288 'S(default())': S<i32>
2483             278..285 'default': fn default<i32>() -> i32
2484             278..287 'default()': i32
2485             295..296 'S': S<{unknown}>({unknown}) -> S<{unknown}>
2486             295..307 'S(default())': S<{unknown}>
2487             297..304 'default': fn default<{unknown}>() -> {unknown}
2488             297..306 'default()': {unknown}
2489         "#]],
2490     );
2491 }
2492
2493 #[test]
2494 fn assoc_types_from_bounds() {
2495     check_infer(
2496         r#"
2497 //- /main.rs
2498 #[lang = "fn_once"]
2499 trait FnOnce<Args> {
2500     type Output;
2501 }
2502
2503 trait T {
2504     type O;
2505 }
2506
2507 impl T for () {
2508     type O = ();
2509 }
2510
2511 fn f<X, F>(_v: F)
2512 where
2513     X: T,
2514     F: FnOnce(&X::O),
2515 { }
2516
2517 fn main() {
2518     f::<(), _>(|z| { z; });
2519 }"#,
2520         expect![[r#"
2521             133..135 '_v': F
2522             178..181 '{ }': ()
2523             193..224 '{     ... }); }': ()
2524             199..209 'f::<(), _>': fn f<(), |&()| -> ()>(|&()| -> ())
2525             199..221 'f::<()... z; })': ()
2526             210..220 '|z| { z; }': |&()| -> ()
2527             211..212 'z': &()
2528             214..220 '{ z; }': ()
2529             216..217 'z': &()
2530         "#]],
2531     );
2532 }
2533
2534 #[test]
2535 fn associated_type_bound() {
2536     check_types(
2537         r#"
2538 pub trait Trait {
2539     type Item: OtherTrait<u32>;
2540 }
2541 pub trait OtherTrait<T> {
2542     fn foo(&self) -> T;
2543 }
2544
2545 // this is just a workaround for chalk#234
2546 pub struct S<T>;
2547 impl<T: Trait> Trait for S<T> {
2548     type Item = <T as Trait>::Item;
2549 }
2550
2551 fn test<T: Trait>() {
2552     let y: <S<T> as Trait>::Item = no_matter;
2553     y.foo();
2554 }       //^ u32
2555 "#,
2556     );
2557 }
2558
2559 #[test]
2560 fn dyn_trait_through_chalk() {
2561     check_types(
2562         r#"
2563 //- minicore: deref
2564 struct Box<T> {}
2565 impl<T> core::ops::Deref for Box<T> {
2566     type Target = T;
2567 }
2568 trait Trait {
2569     fn foo(&self);
2570 }
2571
2572 fn test(x: Box<dyn Trait>) {
2573     x.foo();
2574 }       //^ ()
2575 "#,
2576     );
2577 }
2578
2579 #[test]
2580 fn string_to_owned() {
2581     check_types(
2582         r#"
2583 struct String {}
2584 pub trait ToOwned {
2585     type Owned;
2586     fn to_owned(&self) -> Self::Owned;
2587 }
2588 impl ToOwned for str {
2589     type Owned = String;
2590 }
2591 fn test() {
2592     "foo".to_owned();
2593 }               //^ String
2594 "#,
2595     );
2596 }
2597
2598 #[test]
2599 fn iterator_chain() {
2600     check_infer_with_mismatches(
2601         r#"
2602 //- /main.rs
2603 #[lang = "fn_once"]
2604 trait FnOnce<Args> {
2605     type Output;
2606 }
2607 #[lang = "fn_mut"]
2608 trait FnMut<Args>: FnOnce<Args> { }
2609
2610 enum Option<T> { Some(T), None }
2611 use Option::*;
2612
2613 pub trait Iterator {
2614     type Item;
2615
2616     fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
2617     where
2618         F: FnMut(Self::Item) -> Option<B>,
2619     { loop {} }
2620
2621     fn for_each<F>(self, f: F)
2622     where
2623         F: FnMut(Self::Item),
2624     { loop {} }
2625 }
2626
2627 pub trait IntoIterator {
2628     type Item;
2629     type IntoIter: Iterator<Item = Self::Item>;
2630     fn into_iter(self) -> Self::IntoIter;
2631 }
2632
2633 pub struct FilterMap<I, F> { }
2634 impl<B, I: Iterator, F> Iterator for FilterMap<I, F>
2635 where
2636     F: FnMut(I::Item) -> Option<B>,
2637 {
2638     type Item = B;
2639 }
2640
2641 #[stable(feature = "rust1", since = "1.0.0")]
2642 impl<I: Iterator> IntoIterator for I {
2643     type Item = I::Item;
2644     type IntoIter = I;
2645
2646     fn into_iter(self) -> I {
2647         self
2648     }
2649 }
2650
2651 struct Vec<T> {}
2652 impl<T> Vec<T> {
2653     fn new() -> Self { loop {} }
2654 }
2655
2656 impl<T> IntoIterator for Vec<T> {
2657     type Item = T;
2658     type IntoIter = IntoIter<T>;
2659 }
2660
2661 pub struct IntoIter<T> { }
2662 impl<T> Iterator for IntoIter<T> {
2663     type Item = T;
2664 }
2665
2666 fn main() {
2667     Vec::<i32>::new().into_iter()
2668     .filter_map(|x| if x > 0 { Some(x as u32) } else { None })
2669     .for_each(|y| { y; });
2670 }"#,
2671         expect![[r#"
2672             226..230 'self': Self
2673             232..233 'f': F
2674             317..328 '{ loop {} }': FilterMap<Self, F>
2675             319..326 'loop {}': !
2676             324..326 '{}': ()
2677             349..353 'self': Self
2678             355..356 'f': F
2679             405..416 '{ loop {} }': ()
2680             407..414 'loop {}': !
2681             412..414 '{}': ()
2682             525..529 'self': Self
2683             854..858 'self': I
2684             865..885 '{     ...     }': I
2685             875..879 'self': I
2686             944..955 '{ loop {} }': Vec<T>
2687             946..953 'loop {}': !
2688             951..953 '{}': ()
2689             1142..1269 '{     ... }); }': ()
2690             1148..1163 'Vec::<i32>::new': fn new<i32>() -> Vec<i32>
2691             1148..1165 'Vec::<...:new()': Vec<i32>
2692             1148..1177 'Vec::<...iter()': IntoIter<i32>
2693             1148..1240 'Vec::<...one })': FilterMap<IntoIter<i32>, |i32| -> Option<u32>>
2694             1148..1266 'Vec::<... y; })': ()
2695             1194..1239 '|x| if...None }': |i32| -> Option<u32>
2696             1195..1196 'x': i32
2697             1198..1239 'if x >...None }': Option<u32>
2698             1201..1202 'x': i32
2699             1201..1206 'x > 0': bool
2700             1205..1206 '0': i32
2701             1207..1225 '{ Some...u32) }': Option<u32>
2702             1209..1213 'Some': Some<u32>(u32) -> Option<u32>
2703             1209..1223 'Some(x as u32)': Option<u32>
2704             1214..1215 'x': i32
2705             1214..1222 'x as u32': u32
2706             1231..1239 '{ None }': Option<u32>
2707             1233..1237 'None': Option<u32>
2708             1255..1265 '|y| { y; }': |u32| -> ()
2709             1256..1257 'y': u32
2710             1259..1265 '{ y; }': ()
2711             1261..1262 'y': u32
2712         "#]],
2713     );
2714 }
2715
2716 #[test]
2717 fn nested_assoc() {
2718     check_types(
2719         r#"
2720 struct Bar;
2721 struct Foo;
2722
2723 trait A {
2724     type OutputA;
2725 }
2726
2727 impl A for Bar {
2728     type OutputA = Foo;
2729 }
2730
2731 trait B {
2732     type Output;
2733     fn foo() -> Self::Output;
2734 }
2735
2736 impl<T:A> B for T {
2737     type Output = T::OutputA;
2738     fn foo() -> Self::Output { loop {} }
2739 }
2740
2741 fn main() {
2742     Bar::foo();
2743 }          //^ Foo
2744 "#,
2745     );
2746 }
2747
2748 #[test]
2749 fn trait_object_no_coercion() {
2750     check_infer_with_mismatches(
2751         r#"
2752 trait Foo {}
2753
2754 fn foo(x: &dyn Foo) {}
2755
2756 fn test(x: &dyn Foo) {
2757     foo(x);
2758 }"#,
2759         expect![[r#"
2760             21..22 'x': &dyn Foo
2761             34..36 '{}': ()
2762             46..47 'x': &dyn Foo
2763             59..74 '{     foo(x); }': ()
2764             65..68 'foo': fn foo(&dyn Foo)
2765             65..71 'foo(x)': ()
2766             69..70 'x': &dyn Foo
2767         "#]],
2768     );
2769 }
2770
2771 #[test]
2772 fn builtin_copy() {
2773     check_infer_with_mismatches(
2774         r#"
2775 #[lang = "copy"]
2776 trait Copy {}
2777
2778 struct IsCopy;
2779 impl Copy for IsCopy {}
2780 struct NotCopy;
2781
2782 trait Test { fn test(&self) -> bool; }
2783 impl<T: Copy> Test for T {}
2784
2785 fn test() {
2786     IsCopy.test();
2787     NotCopy.test();
2788     (IsCopy, IsCopy).test();
2789     (IsCopy, NotCopy).test();
2790 }"#,
2791         expect![[r#"
2792             110..114 'self': &Self
2793             166..267 '{     ...t(); }': ()
2794             172..178 'IsCopy': IsCopy
2795             172..185 'IsCopy.test()': bool
2796             191..198 'NotCopy': NotCopy
2797             191..205 'NotCopy.test()': {unknown}
2798             211..227 '(IsCop...sCopy)': (IsCopy, IsCopy)
2799             211..234 '(IsCop...test()': bool
2800             212..218 'IsCopy': IsCopy
2801             220..226 'IsCopy': IsCopy
2802             240..257 '(IsCop...tCopy)': (IsCopy, NotCopy)
2803             240..264 '(IsCop...test()': {unknown}
2804             241..247 'IsCopy': IsCopy
2805             249..256 'NotCopy': NotCopy
2806         "#]],
2807     );
2808 }
2809
2810 #[test]
2811 fn builtin_fn_def_copy() {
2812     check_infer_with_mismatches(
2813         r#"
2814 #[lang = "copy"]
2815 trait Copy {}
2816
2817 fn foo() {}
2818 fn bar<T: Copy>(T) -> T {}
2819 struct Struct(usize);
2820 enum Enum { Variant(usize) }
2821
2822 trait Test { fn test(&self) -> bool; }
2823 impl<T: Copy> Test for T {}
2824
2825 fn test() {
2826     foo.test();
2827     bar.test();
2828     Struct.test();
2829     Enum::Variant.test();
2830 }"#,
2831         expect![[r#"
2832             41..43 '{}': ()
2833             60..61 'T': {unknown}
2834             68..70 '{}': ()
2835             68..70: expected T, got ()
2836             145..149 'self': &Self
2837             201..281 '{     ...t(); }': ()
2838             207..210 'foo': fn foo()
2839             207..217 'foo.test()': bool
2840             223..226 'bar': fn bar<{unknown}>({unknown}) -> {unknown}
2841             223..233 'bar.test()': bool
2842             239..245 'Struct': Struct(usize) -> Struct
2843             239..252 'Struct.test()': bool
2844             258..271 'Enum::Variant': Variant(usize) -> Enum
2845             258..278 'Enum::...test()': bool
2846         "#]],
2847     );
2848 }
2849
2850 #[test]
2851 fn builtin_fn_ptr_copy() {
2852     check_infer_with_mismatches(
2853         r#"
2854 #[lang = "copy"]
2855 trait Copy {}
2856
2857 trait Test { fn test(&self) -> bool; }
2858 impl<T: Copy> Test for T {}
2859
2860 fn test(f1: fn(), f2: fn(usize) -> u8, f3: fn(u8, u8) -> &u8) {
2861     f1.test();
2862     f2.test();
2863     f3.test();
2864 }"#,
2865         expect![[r#"
2866             54..58 'self': &Self
2867             108..110 'f1': fn()
2868             118..120 'f2': fn(usize) -> u8
2869             139..141 'f3': fn(u8, u8) -> &u8
2870             162..210 '{     ...t(); }': ()
2871             168..170 'f1': fn()
2872             168..177 'f1.test()': bool
2873             183..185 'f2': fn(usize) -> u8
2874             183..192 'f2.test()': bool
2875             198..200 'f3': fn(u8, u8) -> &u8
2876             198..207 'f3.test()': bool
2877         "#]],
2878     );
2879 }
2880
2881 #[test]
2882 fn builtin_sized() {
2883     check_infer_with_mismatches(
2884         r#"
2885 #[lang = "sized"]
2886 trait Sized {}
2887
2888 trait Test { fn test(&self) -> bool; }
2889 impl<T: Sized> Test for T {}
2890
2891 fn test() {
2892     1u8.test();
2893     (*"foo").test(); // not Sized
2894     (1u8, 1u8).test();
2895     (1u8, *"foo").test(); // not Sized
2896 }"#,
2897         expect![[r#"
2898             56..60 'self': &Self
2899             113..228 '{     ...ized }': ()
2900             119..122 '1u8': u8
2901             119..129 '1u8.test()': bool
2902             135..150 '(*"foo").test()': {unknown}
2903             136..142 '*"foo"': str
2904             137..142 '"foo"': &str
2905             169..179 '(1u8, 1u8)': (u8, u8)
2906             169..186 '(1u8, ...test()': bool
2907             170..173 '1u8': u8
2908             175..178 '1u8': u8
2909             192..205 '(1u8, *"foo")': (u8, str)
2910             192..212 '(1u8, ...test()': {unknown}
2911             193..196 '1u8': u8
2912             198..204 '*"foo"': str
2913             199..204 '"foo"': &str
2914         "#]],
2915     );
2916 }
2917
2918 #[test]
2919 fn integer_range_iterate() {
2920     check_types(
2921         r#"
2922 //- /main.rs crate:main deps:core
2923 fn test() {
2924     for x in 0..100 { x; }
2925 }                   //^ i32
2926
2927 //- /core.rs crate:core
2928 pub mod ops {
2929     pub struct Range<Idx> {
2930         pub start: Idx,
2931         pub end: Idx,
2932     }
2933 }
2934
2935 pub mod iter {
2936     pub trait Iterator {
2937         type Item;
2938     }
2939
2940     pub trait IntoIterator {
2941         type Item;
2942         type IntoIter: Iterator<Item = Self::Item>;
2943     }
2944
2945     impl<T> IntoIterator for T where T: Iterator {
2946         type Item = <T as Iterator>::Item;
2947         type IntoIter = Self;
2948     }
2949 }
2950
2951 trait Step {}
2952 impl Step for i32 {}
2953 impl Step for i64 {}
2954
2955 impl<A: Step> iter::Iterator for ops::Range<A> {
2956     type Item = A;
2957 }
2958 "#,
2959     );
2960 }
2961
2962 #[test]
2963 fn infer_closure_arg() {
2964     check_infer(
2965         r#"
2966 //- /lib.rs
2967
2968 enum Option<T> {
2969     None,
2970     Some(T)
2971 }
2972
2973 fn foo() {
2974     let s = Option::None;
2975     let f = |x: Option<i32>| {};
2976     (&f)(s)
2977 }"#,
2978         expect![[r#"
2979             52..126 '{     ...)(s) }': ()
2980             62..63 's': Option<i32>
2981             66..78 'Option::None': Option<i32>
2982             88..89 'f': |Option<i32>| -> ()
2983             92..111 '|x: Op...2>| {}': |Option<i32>| -> ()
2984             93..94 'x': Option<i32>
2985             109..111 '{}': ()
2986             117..124 '(&f)(s)': ()
2987             118..120 '&f': &|Option<i32>| -> ()
2988             119..120 'f': |Option<i32>| -> ()
2989             122..123 's': Option<i32>
2990         "#]],
2991     );
2992 }
2993
2994 #[test]
2995 fn infer_fn_trait_arg() {
2996     check_infer_with_mismatches(
2997         r#"
2998         //- /lib.rs deps:std
2999
3000         #[lang = "fn_once"]
3001         pub trait FnOnce<Args> {
3002             type Output;
3003
3004             extern "rust-call" fn call_once(&self, args: Args) -> Self::Output;
3005         }
3006
3007         #[lang = "fn"]
3008         pub trait Fn<Args>:FnOnce<Args> {
3009             extern "rust-call" fn call(&self, args: Args) -> Self::Output;
3010         }
3011
3012         enum Option<T> {
3013             None,
3014             Some(T)
3015         }
3016
3017         fn foo<F, T>(f: F) -> T
3018         where
3019             F: Fn(Option<i32>) -> T,
3020         {
3021             let s = None;
3022             f(s)
3023         }
3024         "#,
3025         expect![[r#"
3026             101..105 'self': &Self
3027             107..111 'args': Args
3028             220..224 'self': &Self
3029             226..230 'args': Args
3030             313..314 'f': F
3031             359..389 '{     ...f(s) }': T
3032             369..370 's': Option<i32>
3033             373..377 'None': Option<i32>
3034             383..384 'f': F
3035             383..387 'f(s)': T
3036             385..386 's': Option<i32>
3037         "#]],
3038     );
3039 }
3040
3041 #[test]
3042 fn infer_box_fn_arg() {
3043     // The type mismatch is because we don't define Unsize and CoerceUnsized
3044     check_infer_with_mismatches(
3045         r#"
3046 //- /lib.rs deps:std
3047
3048 #[lang = "fn_once"]
3049 pub trait FnOnce<Args> {
3050     type Output;
3051
3052     extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
3053 }
3054
3055 #[lang = "deref"]
3056 pub trait Deref {
3057     type Target: ?Sized;
3058
3059     fn deref(&self) -> &Self::Target;
3060 }
3061
3062 #[lang = "owned_box"]
3063 pub struct Box<T: ?Sized> {
3064     inner: *mut T,
3065 }
3066
3067 impl<T: ?Sized> Deref for Box<T> {
3068     type Target = T;
3069
3070     fn deref(&self) -> &T {
3071         &self.inner
3072     }
3073 }
3074
3075 enum Option<T> {
3076     None,
3077     Some(T)
3078 }
3079
3080 fn foo() {
3081     let s = Option::None;
3082     let f: Box<dyn FnOnce(&Option<i32>)> = box (|ps| {});
3083     f(&s);
3084 }"#,
3085         expect![[r#"
3086             100..104 'self': Self
3087             106..110 'args': Args
3088             214..218 'self': &Self
3089             384..388 'self': &Box<T>
3090             396..423 '{     ...     }': &T
3091             406..417 '&self.inner': &*mut T
3092             407..411 'self': &Box<T>
3093             407..417 'self.inner': *mut T
3094             478..576 '{     ...&s); }': ()
3095             488..489 's': Option<i32>
3096             492..504 'Option::None': Option<i32>
3097             514..515 'f': Box<dyn FnOnce(&Option<i32>)>
3098             549..562 'box (|ps| {})': Box<|{unknown}| -> ()>
3099             554..561 '|ps| {}': |{unknown}| -> ()
3100             555..557 'ps': {unknown}
3101             559..561 '{}': ()
3102             568..569 'f': Box<dyn FnOnce(&Option<i32>)>
3103             568..573 'f(&s)': ()
3104             570..572 '&s': &Option<i32>
3105             571..572 's': Option<i32>
3106             549..562: expected Box<dyn FnOnce(&Option<i32>)>, got Box<|{unknown}| -> ()>
3107         "#]],
3108     );
3109 }
3110
3111 #[test]
3112 fn infer_dyn_fn_output() {
3113     check_types(
3114         r#"
3115 #[lang = "fn_once"]
3116 pub trait FnOnce<Args> {
3117     type Output;
3118     extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
3119 }
3120
3121 #[lang = "fn"]
3122 pub trait Fn<Args>: FnOnce<Args> {
3123     extern "rust-call" fn call(&self, args: Args) -> Self::Output;
3124 }
3125
3126 fn foo() {
3127     let f: &dyn Fn() -> i32;
3128     f();
3129   //^^^ i32
3130 }"#,
3131     );
3132 }
3133
3134 #[test]
3135 fn infer_dyn_fn_once_output() {
3136     check_types(
3137         r#"
3138 #[lang = "fn_once"]
3139 pub trait FnOnce<Args> {
3140     type Output;
3141     extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
3142 }
3143
3144 fn foo() {
3145     let f: dyn FnOnce() -> i32;
3146     f();
3147   //^^^ i32
3148 }"#,
3149     );
3150 }
3151
3152 #[test]
3153 fn variable_kinds_1() {
3154     check_types(
3155         r#"
3156 trait Trait<T> { fn get(self, t: T) -> T; }
3157 struct S;
3158 impl Trait<u128> for S {}
3159 impl Trait<f32> for S {}
3160 fn test() {
3161     S.get(1);
3162   //^^^^^^^^ u128
3163     S.get(1.);
3164   //^^^^^^^^ f32
3165 }
3166         "#,
3167     );
3168 }
3169
3170 #[test]
3171 fn variable_kinds_2() {
3172     check_types(
3173         r#"
3174 trait Trait { fn get(self) -> Self; }
3175 impl Trait for u128 {}
3176 impl Trait for f32 {}
3177 fn test() {
3178     1.get();
3179   //^^^^^^^ u128
3180     (1.).get();
3181   //^^^^^^^^^^ f32
3182 }
3183         "#,
3184     );
3185 }
3186
3187 #[test]
3188 fn underscore_import() {
3189     check_types(
3190         r#"
3191 mod tr {
3192     pub trait Tr {
3193         fn method(&self) -> u8 { 0 }
3194     }
3195 }
3196
3197 struct Tr;
3198 impl crate::tr::Tr for Tr {}
3199
3200 use crate::tr::Tr as _;
3201 fn test() {
3202     Tr.method();
3203   //^^^^^^^^^^^ u8
3204 }
3205     "#,
3206     );
3207 }
3208
3209 #[test]
3210 fn inner_use() {
3211     check_types(
3212         r#"
3213 mod m {
3214     pub trait Tr {
3215         fn method(&self) -> u8 { 0 }
3216     }
3217
3218     impl Tr for () {}
3219 }
3220
3221 fn f() {
3222     use m::Tr;
3223
3224     ().method();
3225   //^^^^^^^^^^^ u8
3226 }
3227         "#,
3228     );
3229 }
3230
3231 #[test]
3232 fn trait_in_scope_with_inner_item() {
3233     check_infer(
3234         r#"
3235 mod m {
3236     pub trait Tr {
3237         fn method(&self) -> u8 { 0 }
3238     }
3239
3240     impl Tr for () {}
3241 }
3242
3243 use m::Tr;
3244
3245 fn f() {
3246     fn inner() {
3247         ().method();
3248       //^^^^^^^^^^^ u8
3249     }
3250 }"#,
3251         expect![[r#"
3252             46..50 'self': &Self
3253             58..63 '{ 0 }': u8
3254             60..61 '0': u8
3255             115..185 '{     ...   } }': ()
3256             132..183 '{     ...     }': ()
3257             142..144 '()': ()
3258             142..153 '().method()': u8
3259         "#]],
3260     );
3261 }
3262
3263 #[test]
3264 fn inner_use_in_block() {
3265     check_types(
3266         r#"
3267 mod m {
3268     pub trait Tr {
3269         fn method(&self) -> u8 { 0 }
3270     }
3271
3272     impl Tr for () {}
3273 }
3274
3275 fn f() {
3276     {
3277         use m::Tr;
3278
3279         ().method();
3280       //^^^^^^^^^^^ u8
3281     }
3282
3283     {
3284         ().method();
3285       //^^^^^^^^^^^ {unknown}
3286     }
3287
3288     ().method();
3289   //^^^^^^^^^^^ {unknown}
3290 }
3291         "#,
3292     );
3293 }
3294
3295 #[test]
3296 fn nested_inner_function_calling_self() {
3297     check_infer(
3298         r#"
3299 struct S;
3300 fn f() {
3301     fn inner() -> S {
3302         let s = inner();
3303     }
3304 }"#,
3305         expect![[r#"
3306             17..73 '{     ...   } }': ()
3307             39..71 '{     ...     }': ()
3308             53..54 's': S
3309             57..62 'inner': fn inner() -> S
3310             57..64 'inner()': S
3311         "#]],
3312     )
3313 }
3314
3315 #[test]
3316 fn infer_default_trait_type_parameter() {
3317     check_infer(
3318         r#"
3319 struct A;
3320
3321 trait Op<RHS=Self> {
3322     type Output;
3323
3324     fn do_op(self, rhs: RHS) -> Self::Output;
3325 }
3326
3327 impl Op for A {
3328     type Output = bool;
3329
3330     fn do_op(self, rhs: Self) -> Self::Output {
3331         true
3332     }
3333 }
3334
3335 fn test() {
3336     let x = A;
3337     let y = A;
3338     let r = x.do_op(y);
3339 }"#,
3340         expect![[r#"
3341             63..67 'self': Self
3342             69..72 'rhs': RHS
3343             153..157 'self': A
3344             159..162 'rhs': A
3345             186..206 '{     ...     }': bool
3346             196..200 'true': bool
3347             220..277 '{     ...(y); }': ()
3348             230..231 'x': A
3349             234..235 'A': A
3350             245..246 'y': A
3351             249..250 'A': A
3352             260..261 'r': bool
3353             264..265 'x': A
3354             264..274 'x.do_op(y)': bool
3355             272..273 'y': A
3356         "#]],
3357     )
3358 }
3359
3360 #[test]
3361 fn qualified_path_as_qualified_trait() {
3362     check_infer(
3363         r#"
3364 mod foo {
3365
3366     pub trait Foo {
3367         type Target;
3368     }
3369     pub trait Bar {
3370         type Output;
3371         fn boo() -> Self::Output {
3372             loop {}
3373         }
3374     }
3375 }
3376
3377 struct F;
3378 impl foo::Foo for F {
3379     type Target = ();
3380 }
3381 impl foo::Bar for F {
3382     type Output = <F as foo::Foo>::Target;
3383 }
3384
3385 fn foo() {
3386     use foo::Bar;
3387     let x = <F as Bar>::boo();
3388 }"#,
3389         expect![[r#"
3390             132..163 '{     ...     }': Bar::Output<Self>
3391             146..153 'loop {}': !
3392             151..153 '{}': ()
3393             306..358 '{     ...o(); }': ()
3394             334..335 'x': ()
3395             338..353 '<F as Bar>::boo': fn boo<F>() -> <F as Bar>::Output
3396             338..355 '<F as ...:boo()': ()
3397         "#]],
3398     );
3399 }
3400
3401 #[test]
3402 fn renamed_extern_crate_in_block() {
3403     check_types(
3404         r#"
3405 //- /lib.rs crate:lib deps:serde
3406 use serde::Deserialize;
3407
3408 struct Foo {}
3409
3410 const _ : () = {
3411     extern crate serde as _serde;
3412     impl _serde::Deserialize for Foo {
3413         fn deserialize() -> u8 { 0 }
3414     }
3415 };
3416
3417 fn foo() {
3418     Foo::deserialize();
3419   //^^^^^^^^^^^^^^^^^^ u8
3420 }
3421
3422 //- /serde.rs crate:serde
3423
3424 pub trait Deserialize {
3425     fn deserialize() -> u8;
3426 }"#,
3427     );
3428 }
3429
3430 #[test]
3431 fn bin_op_adt_with_rhs_primitive() {
3432     check_infer_with_mismatches(
3433         r#"
3434 #[lang = "add"]
3435 pub trait Add<Rhs = Self> {
3436     type Output;
3437     fn add(self, rhs: Rhs) -> Self::Output;
3438 }
3439
3440 struct Wrapper(u32);
3441 impl Add<u32> for Wrapper {
3442     type Output = Self;
3443     fn add(self, rhs: u32) -> Wrapper {
3444         Wrapper(rhs)
3445     }
3446 }
3447 fn main(){
3448     let wrapped = Wrapper(10);
3449     let num: u32 = 2;
3450     let res = wrapped + num;
3451
3452 }"#,
3453         expect![[r#"
3454             72..76 'self': Self
3455             78..81 'rhs': Rhs
3456             192..196 'self': Wrapper
3457             198..201 'rhs': u32
3458             219..247 '{     ...     }': Wrapper
3459             229..236 'Wrapper': Wrapper(u32) -> Wrapper
3460             229..241 'Wrapper(rhs)': Wrapper
3461             237..240 'rhs': u32
3462             259..345 '{     ...um;  }': ()
3463             269..276 'wrapped': Wrapper
3464             279..286 'Wrapper': Wrapper(u32) -> Wrapper
3465             279..290 'Wrapper(10)': Wrapper
3466             287..289 '10': u32
3467             300..303 'num': u32
3468             311..312 '2': u32
3469             322..325 'res': Wrapper
3470             328..335 'wrapped': Wrapper
3471             328..341 'wrapped + num': Wrapper
3472             338..341 'num': u32
3473         "#]],
3474     )
3475 }
3476
3477 #[test]
3478 fn array_length() {
3479     check_infer(
3480         r#"
3481 trait T {
3482     type Output;
3483     fn do_thing(&self) -> Self::Output;
3484 }
3485
3486 impl T for [u8; 4] {
3487     type Output = usize;
3488     fn do_thing(&self) -> Self::Output {
3489         2
3490     }
3491 }
3492
3493 impl T for [u8; 2] {
3494     type Output = u8;
3495     fn do_thing(&self) -> Self::Output {
3496         2
3497     }
3498 }
3499
3500 fn main() {
3501     let v = [0u8; 2];
3502     let v2 = v.do_thing();
3503     let v3 = [0u8; 4];
3504     let v4 = v3.do_thing();
3505 }
3506 "#,
3507         expect![[r#"
3508             44..48 'self': &Self
3509             133..137 'self': &[u8; 4]
3510             155..172 '{     ...     }': usize
3511             165..166 '2': usize
3512             236..240 'self': &[u8; 2]
3513             258..275 '{     ...     }': u8
3514             268..269 '2': u8
3515             289..392 '{     ...g(); }': ()
3516             299..300 'v': [u8; 2]
3517             303..311 '[0u8; 2]': [u8; 2]
3518             304..307 '0u8': u8
3519             309..310 '2': usize
3520             321..323 'v2': u8
3521             326..327 'v': [u8; 2]
3522             326..338 'v.do_thing()': u8
3523             348..350 'v3': [u8; 4]
3524             353..361 '[0u8; 4]': [u8; 4]
3525             354..357 '0u8': u8
3526             359..360 '4': usize
3527             371..373 'v4': usize
3528             376..378 'v3': [u8; 4]
3529             376..389 'v3.do_thing()': usize
3530         "#]],
3531     )
3532 }
3533
3534 // FIXME: We should infer the length of the returned array :)
3535 #[test]
3536 fn const_generics() {
3537     check_infer(
3538         r#"
3539 trait T {
3540     type Output;
3541     fn do_thing(&self) -> Self::Output;
3542 }
3543
3544 impl<const L: usize> T for [u8; L] {
3545     type Output = [u8; L];
3546     fn do_thing(&self) -> Self::Output {
3547         *self
3548     }
3549 }
3550
3551 fn main() {
3552     let v = [0u8; 2];
3553     let v2 = v.do_thing();
3554 }
3555 "#,
3556         expect![[r#"
3557             44..48 'self': &Self
3558             151..155 'self': &[u8; _]
3559             173..194 '{     ...     }': [u8; _]
3560             183..188 '*self': [u8; _]
3561             184..188 'self': &[u8; _]
3562             208..260 '{     ...g(); }': ()
3563             218..219 'v': [u8; 2]
3564             222..230 '[0u8; 2]': [u8; 2]
3565             223..226 '0u8': u8
3566             228..229 '2': usize
3567             240..242 'v2': [u8; _]
3568             245..246 'v': [u8; 2]
3569             245..257 'v.do_thing()': [u8; _]
3570         "#]],
3571     )
3572 }
3573
3574 #[test]
3575 fn fn_returning_unit() {
3576     check_infer_with_mismatches(
3577         r#"
3578 #[lang = "fn_once"]
3579 trait FnOnce<Args> {
3580     type Output;
3581 }
3582
3583 fn test<F: FnOnce()>(f: F) {
3584     let _: () = f();
3585 }"#,
3586         expect![[r#"
3587             82..83 'f': F
3588             88..112 '{     ...f(); }': ()
3589             98..99 '_': ()
3590             106..107 'f': F
3591             106..109 'f()': ()
3592         "#]],
3593     );
3594 }
3595
3596 #[test]
3597 fn trait_in_scope_of_trait_impl() {
3598     check_infer(
3599         r#"
3600 mod foo {
3601     pub trait Foo {
3602         fn foo(self);
3603         fn bar(self) -> usize { 0 }
3604     }
3605 }
3606 impl foo::Foo for u32 {
3607     fn foo(self) {
3608         let _x = self.bar();
3609     }
3610 }
3611     "#,
3612         expect![[r#"
3613             45..49 'self': Self
3614             67..71 'self': Self
3615             82..87 '{ 0 }': usize
3616             84..85 '0': usize
3617             131..135 'self': u32
3618             137..173 '{     ...     }': ()
3619             151..153 '_x': usize
3620             156..160 'self': u32
3621             156..166 'self.bar()': usize
3622         "#]],
3623     );
3624 }
3625
3626 #[test]
3627 fn infer_async_ret_type() {
3628     check_types(
3629         r#"
3630 //- /main.rs crate:main deps:core
3631
3632 enum Result<T, E> {
3633     Ok(T),
3634     Err(E),
3635 }
3636
3637 use Result::*;
3638
3639
3640 struct Fooey;
3641
3642 impl Fooey {
3643     fn collect<B: Convert>(self) -> B {
3644         B::new()
3645     }
3646 }
3647
3648 trait Convert {
3649     fn new() -> Self;
3650 }
3651 impl Convert for u32 {
3652     fn new() -> Self {
3653         0
3654     }
3655 }
3656
3657 async fn get_accounts() -> Result<u32, ()> {
3658     let ret = Fooey.collect();
3659     //                      ^ u32
3660     Ok(ret)
3661 }
3662
3663 //- /core.rs crate:core
3664 #[prelude_import] use future::*;
3665 mod future {
3666     #[lang = "future_trait"]
3667     trait Future {
3668         type Output;
3669     }
3670 }
3671 "#,
3672     );
3673 }
3674
3675 #[test]
3676 fn local_impl_1() {
3677     check_types(
3678         r#"
3679 trait Trait<T> {
3680     fn foo(&self) -> T;
3681 }
3682
3683 fn test() {
3684     struct S;
3685     impl Trait<u32> for S {
3686         fn foo(&self) { 0 }
3687     }
3688
3689     S.foo();
3690  // ^^^^^^^ u32
3691 }
3692 "#,
3693     );
3694 }
3695
3696 #[test]
3697 fn local_impl_2() {
3698     check_types(
3699         r#"
3700 struct S;
3701
3702 fn test() {
3703     trait Trait<T> {
3704         fn foo(&self) -> T;
3705     }
3706     impl Trait<u32> for S {
3707         fn foo(&self) { 0 }
3708     }
3709
3710     S.foo();
3711  // ^^^^^^^ u32
3712 }
3713 "#,
3714     );
3715 }
3716
3717 #[test]
3718 fn local_impl_3() {
3719     check_types(
3720         r#"
3721 trait Trait<T> {
3722     fn foo(&self) -> T;
3723 }
3724
3725 fn test() {
3726     struct S1;
3727     {
3728         struct S2;
3729
3730         impl Trait<S1> for S2 {
3731             fn foo(&self) { S1 }
3732         }
3733
3734         S2.foo();
3735      // ^^^^^^^^ S1
3736     }
3737 }
3738 "#,
3739     );
3740 }