crates/ra_hir_ty/src/tests.rs

   1 mod never_type;
   2 mod coercion;
   3
   4 use std::fmt::Write;
   5 use std::sync::Arc;
   6
   7 use hir_def::{
   8     body::BodySourceMap, db::DefDatabase, nameres::CrateDefMap, AssocItemId, DefWithBodyId,
   9     LocalModuleId, Lookup, ModuleDefId,
  10 };
  11 use hir_expand::InFile;
  12 use insta::assert_snapshot;
  13 use ra_db::{fixture::WithFixture, salsa::Database, FilePosition, SourceDatabase};
  14 use ra_syntax::{
  15     algo,
  16     ast::{self, AstNode},
  17 };
  18 use test_utils::covers;
  19
  20 use crate::{db::HirDatabase, display::HirDisplay, test_db::TestDB, InferenceResult};
  21
  22 // These tests compare the inference results for all expressions in a file
  23 // against snapshots of the expected results using insta. Use cargo-insta to
  24 // update the snapshots.
  25
  26 #[test]
  27 fn cfg_impl_block() {
  28     let (db, pos) = TestDB::with_position(
  29         r#"
  30 //- /main.rs crate:main deps:foo cfg:test
  31 use foo::S as T;
  32 struct S;
  33
  34 #[cfg(test)]
  35 impl S {
  36     fn foo1(&self) -> i32 { 0 }
  37 }
  38
  39 #[cfg(not(test))]
  40 impl S {
  41     fn foo2(&self) -> i32 { 0 }
  42 }
  43
  44 fn test() {
  45     let t = (S.foo1(), S.foo2(), T.foo3(), T.foo4());
  46     t<|>;
  47 }
  48
  49 //- /foo.rs crate:foo
  50 struct S;
  51
  52 #[cfg(not(test))]
  53 impl S {
  54     fn foo3(&self) -> i32 { 0 }
  55 }
  56
  57 #[cfg(test)]
  58 impl S {
  59     fn foo4(&self) -> i32 { 0 }
  60 }
  61 "#,
  62     );
  63     assert_eq!("(i32, {unknown}, i32, {unknown})", type_at_pos(&db, pos));
  64 }
  65
  66 #[test]
  67 fn infer_await() {
  68     let (db, pos) = TestDB::with_position(
  69         r#"
  70 //- /main.rs crate:main deps:std
  71
  72 struct IntFuture;
  73
  74 impl Future for IntFuture {
  75     type Output = u64;
  76 }
  77
  78 fn test() {
  79     let r = IntFuture;
  80     let v = r.await;
  81     v<|>;
  82 }
  83
  84 //- /std.rs crate:std
  85 #[prelude_import] use future::*;
  86 mod future {
  87     trait Future {
  88         type Output;
  89     }
  90 }
  91
  92 "#,
  93     );
  94     assert_eq!("u64", type_at_pos(&db, pos));
  95 }
  96
  97 #[test]
  98 fn infer_box() {
  99     let (db, pos) = TestDB::with_position(
 100         r#"
 101 //- /main.rs crate:main deps:std
 102
 103 fn test() {
 104     let x = box 1;
 105     let t = (x, box x, box &1, box [1]);
 106     t<|>;
 107 }
 108
 109 //- /std.rs crate:std
 110 #[prelude_import] use prelude::*;
 111 mod prelude {}
 112
 113 mod boxed {
 114     pub struct Box<T: ?Sized> {
 115         inner: *mut T,
 116     }
 117 }
 118
 119 "#,
 120     );
 121     assert_eq!("(Box<i32>, Box<Box<i32>>, Box<&i32>, Box<[i32;_]>)", type_at_pos(&db, pos));
 122 }
 123
 124 #[test]
 125 fn infer_adt_self() {
 126     let (db, pos) = TestDB::with_position(
 127         r#"
 128 //- /main.rs
 129 enum Nat { Succ(Self), Demo(Nat), Zero }
 130
 131 fn test() {
 132     let foo: Nat = Nat::Zero;
 133     if let Nat::Succ(x) = foo {
 134         x<|>
 135     }
 136 }
 137
 138 "#,
 139     );
 140     assert_eq!("Nat", type_at_pos(&db, pos));
 141 }
 142
 143 #[test]
 144 fn infer_try() {
 145     let (db, pos) = TestDB::with_position(
 146         r#"
 147 //- /main.rs crate:main deps:std
 148
 149 fn test() {
 150     let r: Result<i32, u64> = Result::Ok(1);
 151     let v = r?;
 152     v<|>;
 153 }
 154
 155 //- /std.rs crate:std
 156
 157 #[prelude_import] use ops::*;
 158 mod ops {
 159     trait Try {
 160         type Ok;
 161         type Error;
 162     }
 163 }
 164
 165 #[prelude_import] use result::*;
 166 mod result {
 167     enum Result<O, E> {
 168         Ok(O),
 169         Err(E)
 170     }
 171
 172     impl<O, E> crate::ops::Try for Result<O, E> {
 173         type Ok = O;
 174         type Error = E;
 175     }
 176 }
 177
 178 "#,
 179     );
 180     assert_eq!("i32", type_at_pos(&db, pos));
 181 }
 182
 183 #[test]
 184 fn infer_for_loop() {
 185     let (db, pos) = TestDB::with_position(
 186         r#"
 187 //- /main.rs crate:main deps:std
 188
 189 use std::collections::Vec;
 190
 191 fn test() {
 192     let v = Vec::new();
 193     v.push("foo");
 194     for x in v {
 195         x<|>;
 196     }
 197 }
 198
 199 //- /std.rs crate:std
 200
 201 #[prelude_import] use iter::*;
 202 mod iter {
 203     trait IntoIterator {
 204         type Item;
 205     }
 206 }
 207
 208 mod collections {
 209     struct Vec<T> {}
 210     impl<T> Vec<T> {
 211         fn new() -> Self { Vec {} }
 212         fn push(&mut self, t: T) { }
 213     }
 214
 215     impl<T> crate::iter::IntoIterator for Vec<T> {
 216         type Item=T;
 217     }
 218 }
 219 "#,
 220     );
 221     assert_eq!("&str", type_at_pos(&db, pos));
 222 }
 223
 224 #[test]
 225 fn infer_ranges() {
 226     let (db, pos) = TestDB::with_position(
 227         r#"
 228 //- /main.rs crate:main deps:std
 229 fn test() {
 230     let a = ..;
 231     let b = 1..;
 232     let c = ..2u32;
 233     let d = 1..2usize;
 234     let e = ..=10;
 235     let f = 'a'..='z';
 236
 237     let t = (a, b, c, d, e, f);
 238     t<|>;
 239 }
 240
 241 //- /std.rs crate:std
 242 #[prelude_import] use prelude::*;
 243 mod prelude {}
 244
 245 pub mod ops {
 246     pub struct Range<Idx> {
 247         pub start: Idx,
 248         pub end: Idx,
 249     }
 250     pub struct RangeFrom<Idx> {
 251         pub start: Idx,
 252     }
 253     struct RangeFull;
 254     pub struct RangeInclusive<Idx> {
 255         start: Idx,
 256         end: Idx,
 257         is_empty: u8,
 258     }
 259     pub struct RangeTo<Idx> {
 260         pub end: Idx,
 261     }
 262     pub struct RangeToInclusive<Idx> {
 263         pub end: Idx,
 264     }
 265 }
 266 "#,
 267     );
 268     assert_eq!(
 269         "(RangeFull, RangeFrom<i32>, RangeTo<u32>, Range<usize>, RangeToInclusive<i32>, RangeInclusive<char>)",
 270         type_at_pos(&db, pos),
 271     );
 272 }
 273
 274 #[test]
 275 fn infer_while_let() {
 276     let (db, pos) = TestDB::with_position(
 277         r#"
 278 //- /main.rs
 279 enum Option<T> { Some(T), None }
 280
 281 fn test() {
 282     let foo: Option<f32> = None;
 283     while let Option::Some(x) = foo {
 284         <|>x
 285     }
 286 }
 287
 288 "#,
 289     );
 290     assert_eq!("f32", type_at_pos(&db, pos));
 291 }
 292
 293 #[test]
 294 fn infer_basics() {
 295     assert_snapshot!(
 296         infer(r#"
 297 fn test(a: u32, b: isize, c: !, d: &str) {
 298     a;
 299     b;
 300     c;
 301     d;
 302     1usize;
 303     1isize;
 304     "test";
 305     1.0f32;
 306 }"#),
 307         @r###"
 308     [9; 10) 'a': u32
 309     [17; 18) 'b': isize
 310     [27; 28) 'c': !
 311     [33; 34) 'd': &str
 312     [42; 121) '{     ...f32; }': !
 313     [48; 49) 'a': u32
 314     [55; 56) 'b': isize
 315     [62; 63) 'c': !
 316     [69; 70) 'd': &str
 317     [76; 82) '1usize': usize
 318     [88; 94) '1isize': isize
 319     [100; 106) '"test"': &str
 320     [112; 118) '1.0f32': f32
 321     "###
 322     );
 323 }
 324
 325 #[test]
 326 fn infer_let() {
 327     assert_snapshot!(
 328         infer(r#"
 329 fn test() {
 330     let a = 1isize;
 331     let b: usize = 1;
 332     let c = b;
 333     let d: u32;
 334     let e;
 335     let f: i32 = e;
 336 }
 337 "#),
 338         @r###"
 339     [11; 118) '{     ...= e; }': ()
 340     [21; 22) 'a': isize
 341     [25; 31) '1isize': isize
 342     [41; 42) 'b': usize
 343     [52; 53) '1': usize
 344     [63; 64) 'c': usize
 345     [67; 68) 'b': usize
 346     [78; 79) 'd': u32
 347     [94; 95) 'e': i32
 348     [105; 106) 'f': i32
 349     [114; 115) 'e': i32
 350     "###
 351     );
 352 }
 353
 354 #[test]
 355 fn infer_paths() {
 356     assert_snapshot!(
 357         infer(r#"
 358 fn a() -> u32 { 1 }
 359
 360 mod b {
 361     fn c() -> u32 { 1 }
 362 }
 363
 364 fn test() {
 365     a();
 366     b::c();
 367 }
 368 "#),
 369         @r###"
 370     [15; 20) '{ 1 }': u32
 371     [17; 18) '1': u32
 372     [48; 53) '{ 1 }': u32
 373     [50; 51) '1': u32
 374     [67; 91) '{     ...c(); }': ()
 375     [73; 74) 'a': fn a() -> u32
 376     [73; 76) 'a()': u32
 377     [82; 86) 'b::c': fn c() -> u32
 378     [82; 88) 'b::c()': u32
 379     "###
 380     );
 381 }
 382
 383 #[test]
 384 fn infer_path_type() {
 385     assert_snapshot!(
 386         infer(r#"
 387 struct S;
 388
 389 impl S {
 390     fn foo() -> i32 { 1 }
 391 }
 392
 393 fn test() {
 394     S::foo();
 395     <S>::foo();
 396 }
 397 "#),
 398         @r###"
 399     [41; 46) '{ 1 }': i32
 400     [43; 44) '1': i32
 401     [60; 93) '{     ...o(); }': ()
 402     [66; 72) 'S::foo': fn foo() -> i32
 403     [66; 74) 'S::foo()': i32
 404     [80; 88) '<S>::foo': fn foo() -> i32
 405     [80; 90) '<S>::foo()': i32
 406     "###
 407     );
 408 }
 409
 410 #[test]
 411 fn infer_slice_method() {
 412     assert_snapshot!(
 413         infer(r#"
 414 #[lang = "slice"]
 415 impl<T> [T] {
 416     fn foo(&self) -> T {
 417         loop {}
 418     }
 419 }
 420
 421 #[lang = "slice_alloc"]
 422 impl<T> [T] {}
 423
 424 fn test() {
 425     <[_]>::foo(b"foo");
 426 }
 427 "#),
 428         @r###"
 429     [45; 49) 'self': &[T]
 430     [56; 79) '{     ...     }': T
 431     [66; 73) 'loop {}': !
 432     [71; 73) '{}': ()
 433     [133; 160) '{     ...o"); }': ()
 434     [139; 149) '<[_]>::foo': fn foo<u8>(&[T]) -> T
 435     [139; 157) '<[_]>:..."foo")': u8
 436     [150; 156) 'b"foo"': &[u8]
 437     "###
 438     );
 439 }
 440
 441 #[test]
 442 fn infer_struct() {
 443     assert_snapshot!(
 444         infer(r#"
 445 struct A {
 446     b: B,
 447     c: C,
 448 }
 449 struct B;
 450 struct C(usize);
 451
 452 fn test() {
 453     let c = C(1);
 454     B;
 455     let a: A = A { b: B, c: C(1) };
 456     a.b;
 457     a.c;
 458 }
 459 "#),
 460         @r###"
 461     [72; 154) '{     ...a.c; }': ()
 462     [82; 83) 'c': C
 463     [86; 87) 'C': C(usize) -> C
 464     [86; 90) 'C(1)': C
 465     [88; 89) '1': usize
 466     [96; 97) 'B': B
 467     [107; 108) 'a': A
 468     [114; 133) 'A { b:...C(1) }': A
 469     [121; 122) 'B': B
 470     [127; 128) 'C': C(usize) -> C
 471     [127; 131) 'C(1)': C
 472     [129; 130) '1': usize
 473     [139; 140) 'a': A
 474     [139; 142) 'a.b': B
 475     [148; 149) 'a': A
 476     [148; 151) 'a.c': C
 477     "###
 478     );
 479 }
 480
 481 #[test]
 482 fn infer_enum() {
 483     assert_snapshot!(
 484         infer(r#"
 485 enum E {
 486   V1 { field: u32 },
 487   V2
 488 }
 489 fn test() {
 490   E::V1 { field: 1 };
 491   E::V2;
 492 }"#),
 493         @r###"
 494     [48; 82) '{   E:...:V2; }': ()
 495     [52; 70) 'E::V1 ...d: 1 }': E
 496     [67; 68) '1': u32
 497     [74; 79) 'E::V2': E
 498     "###
 499     );
 500 }
 501
 502 #[test]
 503 fn infer_refs() {
 504     assert_snapshot!(
 505         infer(r#"
 506 fn test(a: &u32, b: &mut u32, c: *const u32, d: *mut u32) {
 507     a;
 508     *a;
 509     &a;
 510     &mut a;
 511     b;
 512     *b;
 513     &b;
 514     c;
 515     *c;
 516     d;
 517     *d;
 518 }
 519 "#),
 520         @r###"
 521     [9; 10) 'a': &u32
 522     [18; 19) 'b': &mut u32
 523     [31; 32) 'c': *const u32
 524     [46; 47) 'd': *mut u32
 525     [59; 150) '{     ... *d; }': ()
 526     [65; 66) 'a': &u32
 527     [72; 74) '*a': u32
 528     [73; 74) 'a': &u32
 529     [80; 82) '&a': &&u32
 530     [81; 82) 'a': &u32
 531     [88; 94) '&mut a': &mut &u32
 532     [93; 94) 'a': &u32
 533     [100; 101) 'b': &mut u32
 534     [107; 109) '*b': u32
 535     [108; 109) 'b': &mut u32
 536     [115; 117) '&b': &&mut u32
 537     [116; 117) 'b': &mut u32
 538     [123; 124) 'c': *const u32
 539     [130; 132) '*c': u32
 540     [131; 132) 'c': *const u32
 541     [138; 139) 'd': *mut u32
 542     [145; 147) '*d': u32
 543     [146; 147) 'd': *mut u32
 544     "###
 545     );
 546 }
 547
 548 #[test]
 549 fn infer_literals() {
 550     assert_snapshot!(
 551         infer(r##"
 552 fn test() {
 553     5i32;
 554     5f32;
 555     5f64;
 556     "hello";
 557     b"bytes";
 558     'c';
 559     b'b';
 560     3.14;
 561     5000;
 562     false;
 563     true;
 564     r#"
 565         //! doc
 566         // non-doc
 567         mod foo {}
 568         "#;
 569     br#"yolo"#;
 570 }
 571 "##),
 572         @r###"
 573     [11; 221) '{     ...o"#; }': ()
 574     [17; 21) '5i32': i32
 575     [27; 31) '5f32': f32
 576     [37; 41) '5f64': f64
 577     [47; 54) '"hello"': &str
 578     [60; 68) 'b"bytes"': &[u8]
 579     [74; 77) ''c'': char
 580     [83; 87) 'b'b'': u8
 581     [93; 97) '3.14': f64
 582     [103; 107) '5000': i32
 583     [113; 118) 'false': bool
 584     [124; 128) 'true': bool
 585     [134; 202) 'r#"   ...    "#': &str
 586     [208; 218) 'br#"yolo"#': &[u8]
 587     "###
 588     );
 589 }
 590
 591 #[test]
 592 fn infer_unary_op() {
 593     assert_snapshot!(
 594         infer(r#"
 595 enum SomeType {}
 596
 597 fn test(x: SomeType) {
 598     let b = false;
 599     let c = !b;
 600     let a = 100;
 601     let d: i128 = -a;
 602     let e = -100;
 603     let f = !!!true;
 604     let g = !42;
 605     let h = !10u32;
 606     let j = !a;
 607     -3.14;
 608     !3;
 609     -x;
 610     !x;
 611     -"hello";
 612     !"hello";
 613 }
 614 "#),
 615         @r###"
 616     [27; 28) 'x': SomeType
 617     [40; 272) '{     ...lo"; }': ()
 618     [50; 51) 'b': bool
 619     [54; 59) 'false': bool
 620     [69; 70) 'c': bool
 621     [73; 75) '!b': bool
 622     [74; 75) 'b': bool
 623     [85; 86) 'a': i128
 624     [89; 92) '100': i128
 625     [102; 103) 'd': i128
 626     [112; 114) '-a': i128
 627     [113; 114) 'a': i128
 628     [124; 125) 'e': i32
 629     [128; 132) '-100': i32
 630     [129; 132) '100': i32
 631     [142; 143) 'f': bool
 632     [146; 153) '!!!true': bool
 633     [147; 153) '!!true': bool
 634     [148; 153) '!true': bool
 635     [149; 153) 'true': bool
 636     [163; 164) 'g': i32
 637     [167; 170) '!42': i32
 638     [168; 170) '42': i32
 639     [180; 181) 'h': u32
 640     [184; 190) '!10u32': u32
 641     [185; 190) '10u32': u32
 642     [200; 201) 'j': i128
 643     [204; 206) '!a': i128
 644     [205; 206) 'a': i128
 645     [212; 217) '-3.14': f64
 646     [213; 217) '3.14': f64
 647     [223; 225) '!3': i32
 648     [224; 225) '3': i32
 649     [231; 233) '-x': {unknown}
 650     [232; 233) 'x': SomeType
 651     [239; 241) '!x': {unknown}
 652     [240; 241) 'x': SomeType
 653     [247; 255) '-"hello"': {unknown}
 654     [248; 255) '"hello"': &str
 655     [261; 269) '!"hello"': {unknown}
 656     [262; 269) '"hello"': &str
 657     "###
 658     );
 659 }
 660
 661 #[test]
 662 fn infer_backwards() {
 663     assert_snapshot!(
 664         infer(r#"
 665 fn takes_u32(x: u32) {}
 666
 667 struct S { i32_field: i32 }
 668
 669 fn test() -> &mut &f64 {
 670     let a = unknown_function();
 671     takes_u32(a);
 672     let b = unknown_function();
 673     S { i32_field: b };
 674     let c = unknown_function();
 675     &mut &c
 676 }
 677 "#),
 678         @r###"
 679     [14; 15) 'x': u32
 680     [22; 24) '{}': ()
 681     [78; 231) '{     ...t &c }': &mut &f64
 682     [88; 89) 'a': u32
 683     [92; 108) 'unknow...nction': {unknown}
 684     [92; 110) 'unknow...tion()': u32
 685     [116; 125) 'takes_u32': fn takes_u32(u32) -> ()
 686     [116; 128) 'takes_u32(a)': ()
 687     [126; 127) 'a': u32
 688     [138; 139) 'b': i32
 689     [142; 158) 'unknow...nction': {unknown}
 690     [142; 160) 'unknow...tion()': i32
 691     [166; 184) 'S { i3...d: b }': S
 692     [181; 182) 'b': i32
 693     [194; 195) 'c': f64
 694     [198; 214) 'unknow...nction': {unknown}
 695     [198; 216) 'unknow...tion()': f64
 696     [222; 229) '&mut &c': &mut &f64
 697     [227; 229) '&c': &f64
 698     [228; 229) 'c': f64
 699     "###
 700     );
 701 }
 702
 703 #[test]
 704 fn infer_self() {
 705     assert_snapshot!(
 706         infer(r#"
 707 struct S;
 708
 709 impl S {
 710     fn test(&self) {
 711         self;
 712     }
 713     fn test2(self: &Self) {
 714         self;
 715     }
 716     fn test3() -> Self {
 717         S {}
 718     }
 719     fn test4() -> Self {
 720         Self {}
 721     }
 722 }
 723 "#),
 724         @r###"
 725     [34; 38) 'self': &S
 726     [40; 61) '{     ...     }': ()
 727     [50; 54) 'self': &S
 728     [75; 79) 'self': &S
 729     [88; 109) '{     ...     }': ()
 730     [98; 102) 'self': &S
 731     [133; 153) '{     ...     }': S
 732     [143; 147) 'S {}': S
 733     [177; 200) '{     ...     }': S
 734     [187; 194) 'Self {}': S
 735     "###
 736     );
 737 }
 738
 739 #[test]
 740 fn infer_binary_op() {
 741     assert_snapshot!(
 742         infer(r#"
 743 fn f(x: bool) -> i32 {
 744     0i32
 745 }
 746
 747 fn test() -> bool {
 748     let x = a && b;
 749     let y = true || false;
 750     let z = x == y;
 751     let t = x != y;
 752     let minus_forty: isize = -40isize;
 753     let h = minus_forty <= CONST_2;
 754     let c = f(z || y) + 5;
 755     let d = b;
 756     let g = minus_forty ^= i;
 757     let ten: usize = 10;
 758     let ten_is_eleven = ten == some_num;
 759
 760     ten < 3
 761 }
 762 "#),
 763         @r###"
 764     [6; 7) 'x': bool
 765     [22; 34) '{     0i32 }': i32
 766     [28; 32) '0i32': i32
 767     [54; 370) '{     ... < 3 }': bool
 768     [64; 65) 'x': bool
 769     [68; 69) 'a': bool
 770     [68; 74) 'a && b': bool
 771     [73; 74) 'b': bool
 772     [84; 85) 'y': bool
 773     [88; 92) 'true': bool
 774     [88; 101) 'true || false': bool
 775     [96; 101) 'false': bool
 776     [111; 112) 'z': bool
 777     [115; 116) 'x': bool
 778     [115; 121) 'x == y': bool
 779     [120; 121) 'y': bool
 780     [131; 132) 't': bool
 781     [135; 136) 'x': bool
 782     [135; 141) 'x != y': bool
 783     [140; 141) 'y': bool
 784     [151; 162) 'minus_forty': isize
 785     [172; 180) '-40isize': isize
 786     [173; 180) '40isize': isize
 787     [190; 191) 'h': bool
 788     [194; 205) 'minus_forty': isize
 789     [194; 216) 'minus_...ONST_2': bool
 790     [209; 216) 'CONST_2': isize
 791     [226; 227) 'c': i32
 792     [230; 231) 'f': fn f(bool) -> i32
 793     [230; 239) 'f(z || y)': i32
 794     [230; 243) 'f(z || y) + 5': i32
 795     [232; 233) 'z': bool
 796     [232; 238) 'z || y': bool
 797     [237; 238) 'y': bool
 798     [242; 243) '5': i32
 799     [253; 254) 'd': {unknown}
 800     [257; 258) 'b': {unknown}
 801     [268; 269) 'g': ()
 802     [272; 283) 'minus_forty': isize
 803     [272; 288) 'minus_...y ^= i': ()
 804     [287; 288) 'i': isize
 805     [298; 301) 'ten': usize
 806     [311; 313) '10': usize
 807     [323; 336) 'ten_is_eleven': bool
 808     [339; 342) 'ten': usize
 809     [339; 354) 'ten == some_num': bool
 810     [346; 354) 'some_num': usize
 811     [361; 364) 'ten': usize
 812     [361; 368) 'ten < 3': bool
 813     [367; 368) '3': usize
 814     "###
 815     );
 816 }
 817
 818 #[test]
 819 fn infer_field_autoderef() {
 820     assert_snapshot!(
 821         infer(r#"
 822 struct A {
 823     b: B,
 824 }
 825 struct B;
 826
 827 fn test1(a: A) {
 828     let a1 = a;
 829     a1.b;
 830     let a2 = &a;
 831     a2.b;
 832     let a3 = &mut a;
 833     a3.b;
 834     let a4 = &&&&&&&a;
 835     a4.b;
 836     let a5 = &mut &&mut &&mut a;
 837     a5.b;
 838 }
 839
 840 fn test2(a1: *const A, a2: *mut A) {
 841     a1.b;
 842     a2.b;
 843 }
 844 "#),
 845         @r###"
 846     [44; 45) 'a': A
 847     [50; 213) '{     ...5.b; }': ()
 848     [60; 62) 'a1': A
 849     [65; 66) 'a': A
 850     [72; 74) 'a1': A
 851     [72; 76) 'a1.b': B
 852     [86; 88) 'a2': &A
 853     [91; 93) '&a': &A
 854     [92; 93) 'a': A
 855     [99; 101) 'a2': &A
 856     [99; 103) 'a2.b': B
 857     [113; 115) 'a3': &mut A
 858     [118; 124) '&mut a': &mut A
 859     [123; 124) 'a': A
 860     [130; 132) 'a3': &mut A
 861     [130; 134) 'a3.b': B
 862     [144; 146) 'a4': &&&&&&&A
 863     [149; 157) '&&&&&&&a': &&&&&&&A
 864     [150; 157) '&&&&&&a': &&&&&&A
 865     [151; 157) '&&&&&a': &&&&&A
 866     [152; 157) '&&&&a': &&&&A
 867     [153; 157) '&&&a': &&&A
 868     [154; 157) '&&a': &&A
 869     [155; 157) '&a': &A
 870     [156; 157) 'a': A
 871     [163; 165) 'a4': &&&&&&&A
 872     [163; 167) 'a4.b': B
 873     [177; 179) 'a5': &mut &&mut &&mut A
 874     [182; 200) '&mut &...&mut a': &mut &&mut &&mut A
 875     [187; 200) '&&mut &&mut a': &&mut &&mut A
 876     [188; 200) '&mut &&mut a': &mut &&mut A
 877     [193; 200) '&&mut a': &&mut A
 878     [194; 200) '&mut a': &mut A
 879     [199; 200) 'a': A
 880     [206; 208) 'a5': &mut &&mut &&mut A
 881     [206; 210) 'a5.b': B
 882     [224; 226) 'a1': *const A
 883     [238; 240) 'a2': *mut A
 884     [250; 273) '{     ...2.b; }': ()
 885     [256; 258) 'a1': *const A
 886     [256; 260) 'a1.b': B
 887     [266; 268) 'a2': *mut A
 888     [266; 270) 'a2.b': B
 889     "###
 890     );
 891 }
 892
 893 #[test]
 894 fn infer_argument_autoderef() {
 895     assert_snapshot!(
 896         infer(r#"
 897 #[lang = "deref"]
 898 pub trait Deref {
 899     type Target;
 900     fn deref(&self) -> &Self::Target;
 901 }
 902
 903 struct A<T>(T);
 904
 905 impl<T> A<T> {
 906     fn foo(&self) -> &T {
 907         &self.0
 908     }
 909 }
 910
 911 struct B<T>(T);
 912
 913 impl<T> Deref for B<T> {
 914     type Target = T;
 915     fn deref(&self) -> &Self::Target {
 916         &self.0
 917     }
 918 }
 919
 920 fn test() {
 921     let t = A::foo(&&B(B(A(42))));
 922 }
 923 "#),
 924         @r###"
 925     [68; 72) 'self': &Self
 926     [139; 143) 'self': &A<T>
 927     [151; 174) '{     ...     }': &T
 928     [161; 168) '&self.0': &T
 929     [162; 166) 'self': &A<T>
 930     [162; 168) 'self.0': T
 931     [255; 259) 'self': &B<T>
 932     [278; 301) '{     ...     }': &T
 933     [288; 295) '&self.0': &T
 934     [289; 293) 'self': &B<T>
 935     [289; 295) 'self.0': T
 936     [315; 353) '{     ...))); }': ()
 937     [325; 326) 't': &i32
 938     [329; 335) 'A::foo': fn foo<i32>(&A<T>) -> &T
 939     [329; 350) 'A::foo...42))))': &i32
 940     [336; 349) '&&B(B(A(42)))': &&B<B<A<i32>>>
 941     [337; 349) '&B(B(A(42)))': &B<B<A<i32>>>
 942     [338; 339) 'B': B<B<A<i32>>>(T) -> B<T>
 943     [338; 349) 'B(B(A(42)))': B<B<A<i32>>>
 944     [340; 341) 'B': B<A<i32>>(T) -> B<T>
 945     [340; 348) 'B(A(42))': B<A<i32>>
 946     [342; 343) 'A': A<i32>(T) -> A<T>
 947     [342; 347) 'A(42)': A<i32>
 948     [344; 346) '42': i32
 949     "###
 950     );
 951 }
 952
 953 #[test]
 954 fn infer_method_argument_autoderef() {
 955     assert_snapshot!(
 956         infer(r#"
 957 #[lang = "deref"]
 958 pub trait Deref {
 959     type Target;
 960     fn deref(&self) -> &Self::Target;
 961 }
 962
 963 struct A<T>(*mut T);
 964
 965 impl<T> A<T> {
 966     fn foo(&self, x: &A<T>) -> &T {
 967         &*x.0
 968     }
 969 }
 970
 971 struct B<T>(T);
 972
 973 impl<T> Deref for B<T> {
 974     type Target = T;
 975     fn deref(&self) -> &Self::Target {
 976         &self.0
 977     }
 978 }
 979
 980 fn test(a: A<i32>) {
 981     let t = A(0 as *mut _).foo(&&B(B(a)));
 982 }
 983 "#),
 984         @r###"
 985     [68; 72) 'self': &Self
 986     [144; 148) 'self': &A<T>
 987     [150; 151) 'x': &A<T>
 988     [166; 187) '{     ...     }': &T
 989     [176; 181) '&*x.0': &T
 990     [177; 181) '*x.0': T
 991     [178; 179) 'x': &A<T>
 992     [178; 181) 'x.0': *mut T
 993     [268; 272) 'self': &B<T>
 994     [291; 314) '{     ...     }': &T
 995     [301; 308) '&self.0': &T
 996     [302; 306) 'self': &B<T>
 997     [302; 308) 'self.0': T
 998     [326; 327) 'a': A<i32>
 999     [337; 383) '{     ...))); }': ()
1000     [347; 348) 't': &i32
1001     [351; 352) 'A': A<i32>(*mut T) -> A<T>
1002     [351; 365) 'A(0 as *mut _)': A<i32>
1003     [351; 380) 'A(0 as...B(a)))': &i32
1004     [353; 354) '0': i32
1005     [353; 364) '0 as *mut _': *mut i32
1006     [370; 379) '&&B(B(a))': &&B<B<A<i32>>>
1007     [371; 379) '&B(B(a))': &B<B<A<i32>>>
1008     [372; 373) 'B': B<B<A<i32>>>(T) -> B<T>
1009     [372; 379) 'B(B(a))': B<B<A<i32>>>
1010     [374; 375) 'B': B<A<i32>>(T) -> B<T>
1011     [374; 378) 'B(a)': B<A<i32>>
1012     [376; 377) 'a': A<i32>
1013     "###
1014     );
1015 }
1016
1017 #[test]
1018 fn bug_484() {
1019     assert_snapshot!(
1020         infer(r#"
1021 fn test() {
1022    let x = if true {};
1023 }
1024 "#),
1025         @r###"
1026     [11; 37) '{    l... {}; }': ()
1027     [20; 21) 'x': ()
1028     [24; 34) 'if true {}': ()
1029     [27; 31) 'true': bool
1030     [32; 34) '{}': ()
1031     "###
1032     );
1033 }
1034
1035 #[test]
1036 fn infer_in_elseif() {
1037     assert_snapshot!(
1038         infer(r#"
1039 struct Foo { field: i32 }
1040 fn main(foo: Foo) {
1041     if true {
1042
1043     } else if false {
1044         foo.field
1045     }
1046 }
1047 "#),
1048         @r###"
1049     [35; 38) 'foo': Foo
1050     [45; 109) '{     ...   } }': ()
1051     [51; 107) 'if tru...     }': ()
1052     [54; 58) 'true': bool
1053     [59; 67) '{      }': ()
1054     [73; 107) 'if fal...     }': ()
1055     [76; 81) 'false': bool
1056     [82; 107) '{     ...     }': i32
1057     [92; 95) 'foo': Foo
1058     [92; 101) 'foo.field': i32
1059     "###
1060     )
1061 }
1062
1063 #[test]
1064 fn infer_if_match_with_return() {
1065     assert_snapshot!(
1066         infer(r#"
1067 fn foo() {
1068     let _x1 = if true {
1069         1
1070     } else {
1071         return;
1072     };
1073     let _x2 = if true {
1074         2
1075     } else {
1076         return
1077     };
1078     let _x3 = match true {
1079         true => 3,
1080         _ => {
1081             return;
1082         }
1083     };
1084     let _x4 = match true {
1085         true => 4,
1086         _ => return
1087     };
1088 }"#),
1089         @r###"
1090     [10; 323) '{     ...  }; }': ()
1091     [20; 23) '_x1': i32
1092     [26; 80) 'if tru...     }': i32
1093     [29; 33) 'true': bool
1094     [34; 51) '{     ...     }': i32
1095     [44; 45) '1': i32
1096     [57; 80) '{     ...     }': !
1097     [67; 73) 'return': !
1098     [90; 93) '_x2': i32
1099     [96; 149) 'if tru...     }': i32
1100     [99; 103) 'true': bool
1101     [104; 121) '{     ...     }': i32
1102     [114; 115) '2': i32
1103     [127; 149) '{     ...     }': !
1104     [137; 143) 'return': !
1105     [159; 162) '_x3': i32
1106     [165; 247) 'match ...     }': i32
1107     [171; 175) 'true': bool
1108     [186; 190) 'true': bool
1109     [194; 195) '3': i32
1110     [205; 206) '_': bool
1111     [210; 241) '{     ...     }': !
1112     [224; 230) 'return': !
1113     [257; 260) '_x4': i32
1114     [263; 320) 'match ...     }': i32
1115     [269; 273) 'true': bool
1116     [284; 288) 'true': bool
1117     [292; 293) '4': i32
1118     [303; 304) '_': bool
1119     [308; 314) 'return': !
1120     "###
1121     )
1122 }
1123
1124 #[test]
1125 fn infer_inherent_method() {
1126     assert_snapshot!(
1127         infer(r#"
1128 struct A;
1129
1130 impl A {
1131     fn foo(self, x: u32) -> i32 {}
1132 }
1133
1134 mod b {
1135     impl super::A {
1136         fn bar(&self, x: u64) -> i64 {}
1137     }
1138 }
1139
1140 fn test(a: A) {
1141     a.foo(1);
1142     (&a).bar(1);
1143     a.bar(1);
1144 }
1145 "#),
1146         @r###"
1147     [32; 36) 'self': A
1148     [38; 39) 'x': u32
1149     [53; 55) '{}': ()
1150     [103; 107) 'self': &A
1151     [109; 110) 'x': u64
1152     [124; 126) '{}': ()
1153     [144; 145) 'a': A
1154     [150; 198) '{     ...(1); }': ()
1155     [156; 157) 'a': A
1156     [156; 164) 'a.foo(1)': i32
1157     [162; 163) '1': u32
1158     [170; 181) '(&a).bar(1)': i64
1159     [171; 173) '&a': &A
1160     [172; 173) 'a': A
1161     [179; 180) '1': u64
1162     [187; 188) 'a': A
1163     [187; 195) 'a.bar(1)': i64
1164     [193; 194) '1': u64
1165     "###
1166     );
1167 }
1168
1169 #[test]
1170 fn infer_inherent_method_str() {
1171     assert_snapshot!(
1172         infer(r#"
1173 #[lang = "str"]
1174 impl str {
1175     fn foo(&self) -> i32 {}
1176 }
1177
1178 fn test() {
1179     "foo".foo();
1180 }
1181 "#),
1182         @r###"
1183     [40; 44) 'self': &str
1184     [53; 55) '{}': ()
1185     [69; 89) '{     ...o(); }': ()
1186     [75; 80) '"foo"': &str
1187     [75; 86) '"foo".foo()': i32
1188     "###
1189     );
1190 }
1191
1192 #[test]
1193 fn infer_tuple() {
1194     assert_snapshot!(
1195         infer(r#"
1196 fn test(x: &str, y: isize) {
1197     let a: (u32, &str) = (1, "a");
1198     let b = (a, x);
1199     let c = (y, x);
1200     let d = (c, x);
1201     let e = (1, "e");
1202     let f = (e, "d");
1203 }
1204 "#),
1205         @r###"
1206     [9; 10) 'x': &str
1207     [18; 19) 'y': isize
1208     [28; 170) '{     ...d"); }': ()
1209     [38; 39) 'a': (u32, &str)
1210     [55; 63) '(1, "a")': (u32, &str)
1211     [56; 57) '1': u32
1212     [59; 62) '"a"': &str
1213     [73; 74) 'b': ((u32, &str), &str)
1214     [77; 83) '(a, x)': ((u32, &str), &str)
1215     [78; 79) 'a': (u32, &str)
1216     [81; 82) 'x': &str
1217     [93; 94) 'c': (isize, &str)
1218     [97; 103) '(y, x)': (isize, &str)
1219     [98; 99) 'y': isize
1220     [101; 102) 'x': &str
1221     [113; 114) 'd': ((isize, &str), &str)
1222     [117; 123) '(c, x)': ((isize, &str), &str)
1223     [118; 119) 'c': (isize, &str)
1224     [121; 122) 'x': &str
1225     [133; 134) 'e': (i32, &str)
1226     [137; 145) '(1, "e")': (i32, &str)
1227     [138; 139) '1': i32
1228     [141; 144) '"e"': &str
1229     [155; 156) 'f': ((i32, &str), &str)
1230     [159; 167) '(e, "d")': ((i32, &str), &str)
1231     [160; 161) 'e': (i32, &str)
1232     [163; 166) '"d"': &str
1233     "###
1234     );
1235 }
1236
1237 #[test]
1238 fn infer_array() {
1239     assert_snapshot!(
1240         infer(r#"
1241 fn test(x: &str, y: isize) {
1242     let a = [x];
1243     let b = [a, a];
1244     let c = [b, b];
1245
1246     let d = [y, 1, 2, 3];
1247     let d = [1, y, 2, 3];
1248     let e = [y];
1249     let f = [d, d];
1250     let g = [e, e];
1251
1252     let h = [1, 2];
1253     let i = ["a", "b"];
1254
1255     let b = [a, ["b"]];
1256     let x: [u8; 0] = [];
1257 }
1258 "#),
1259         @r###"
1260     [9; 10) 'x': &str
1261     [18; 19) 'y': isize
1262     [28; 293) '{     ... []; }': ()
1263     [38; 39) 'a': [&str;_]
1264     [42; 45) '[x]': [&str;_]
1265     [43; 44) 'x': &str
1266     [55; 56) 'b': [[&str;_];_]
1267     [59; 65) '[a, a]': [[&str;_];_]
1268     [60; 61) 'a': [&str;_]
1269     [63; 64) 'a': [&str;_]
1270     [75; 76) 'c': [[[&str;_];_];_]
1271     [79; 85) '[b, b]': [[[&str;_];_];_]
1272     [80; 81) 'b': [[&str;_];_]
1273     [83; 84) 'b': [[&str;_];_]
1274     [96; 97) 'd': [isize;_]
1275     [100; 112) '[y, 1, 2, 3]': [isize;_]
1276     [101; 102) 'y': isize
1277     [104; 105) '1': isize
1278     [107; 108) '2': isize
1279     [110; 111) '3': isize
1280     [122; 123) 'd': [isize;_]
1281     [126; 138) '[1, y, 2, 3]': [isize;_]
1282     [127; 128) '1': isize
1283     [130; 131) 'y': isize
1284     [133; 134) '2': isize
1285     [136; 137) '3': isize
1286     [148; 149) 'e': [isize;_]
1287     [152; 155) '[y]': [isize;_]
1288     [153; 154) 'y': isize
1289     [165; 166) 'f': [[isize;_];_]
1290     [169; 175) '[d, d]': [[isize;_];_]
1291     [170; 171) 'd': [isize;_]
1292     [173; 174) 'd': [isize;_]
1293     [185; 186) 'g': [[isize;_];_]
1294     [189; 195) '[e, e]': [[isize;_];_]
1295     [190; 191) 'e': [isize;_]
1296     [193; 194) 'e': [isize;_]
1297     [206; 207) 'h': [i32;_]
1298     [210; 216) '[1, 2]': [i32;_]
1299     [211; 212) '1': i32
1300     [214; 215) '2': i32
1301     [226; 227) 'i': [&str;_]
1302     [230; 240) '["a", "b"]': [&str;_]
1303     [231; 234) '"a"': &str
1304     [236; 239) '"b"': &str
1305     [251; 252) 'b': [[&str;_];_]
1306     [255; 265) '[a, ["b"]]': [[&str;_];_]
1307     [256; 257) 'a': [&str;_]
1308     [259; 264) '["b"]': [&str;_]
1309     [260; 263) '"b"': &str
1310     [275; 276) 'x': [u8;_]
1311     [288; 290) '[]': [u8;_]
1312     "###
1313     );
1314 }
1315
1316 #[test]
1317 fn infer_pattern() {
1318     assert_snapshot!(
1319         infer(r#"
1320 fn test(x: &i32) {
1321     let y = x;
1322     let &z = x;
1323     let a = z;
1324     let (c, d) = (1, "hello");
1325
1326     for (e, f) in some_iter {
1327         let g = e;
1328     }
1329
1330     if let [val] = opt {
1331         let h = val;
1332     }
1333
1334     let lambda = |a: u64, b, c: i32| { a + b; c };
1335
1336     let ref ref_to_x = x;
1337     let mut mut_x = x;
1338     let ref mut mut_ref_to_x = x;
1339     let k = mut_ref_to_x;
1340 }
1341 "#),
1342         @r###"
1343     [9; 10) 'x': &i32
1344     [18; 369) '{     ...o_x; }': ()
1345     [28; 29) 'y': &i32
1346     [32; 33) 'x': &i32
1347     [43; 45) '&z': &i32
1348     [44; 45) 'z': i32
1349     [48; 49) 'x': &i32
1350     [59; 60) 'a': i32
1351     [63; 64) 'z': i32
1352     [74; 80) '(c, d)': (i32, &str)
1353     [75; 76) 'c': i32
1354     [78; 79) 'd': &str
1355     [83; 95) '(1, "hello")': (i32, &str)
1356     [84; 85) '1': i32
1357     [87; 94) '"hello"': &str
1358     [102; 152) 'for (e...     }': ()
1359     [106; 112) '(e, f)': ({unknown}, {unknown})
1360     [107; 108) 'e': {unknown}
1361     [110; 111) 'f': {unknown}
1362     [116; 125) 'some_iter': {unknown}
1363     [126; 152) '{     ...     }': ()
1364     [140; 141) 'g': {unknown}
1365     [144; 145) 'e': {unknown}
1366     [158; 205) 'if let...     }': ()
1367     [165; 170) '[val]': {unknown}
1368     [173; 176) 'opt': {unknown}
1369     [177; 205) '{     ...     }': ()
1370     [191; 192) 'h': {unknown}
1371     [195; 198) 'val': {unknown}
1372     [215; 221) 'lambda': |u64, u64, i32| -> i32
1373     [224; 256) '|a: u6...b; c }': |u64, u64, i32| -> i32
1374     [225; 226) 'a': u64
1375     [233; 234) 'b': u64
1376     [236; 237) 'c': i32
1377     [244; 256) '{ a + b; c }': i32
1378     [246; 247) 'a': u64
1379     [246; 251) 'a + b': u64
1380     [250; 251) 'b': u64
1381     [253; 254) 'c': i32
1382     [267; 279) 'ref ref_to_x': &&i32
1383     [282; 283) 'x': &i32
1384     [293; 302) 'mut mut_x': &i32
1385     [305; 306) 'x': &i32
1386     [316; 336) 'ref mu...f_to_x': &mut &i32
1387     [339; 340) 'x': &i32
1388     [350; 351) 'k': &mut &i32
1389     [354; 366) 'mut_ref_to_x': &mut &i32
1390     "###
1391     );
1392 }
1393
1394 #[test]
1395 fn infer_pattern_match_ergonomics() {
1396     assert_snapshot!(
1397         infer(r#"
1398 struct A<T>(T);
1399
1400 fn test() {
1401     let A(n) = &A(1);
1402     let A(n) = &mut A(1);
1403 }
1404 "#),
1405     @r###"
1406     [28; 79) '{     ...(1); }': ()
1407     [38; 42) 'A(n)': A<i32>
1408     [40; 41) 'n': &i32
1409     [45; 50) '&A(1)': &A<i32>
1410     [46; 47) 'A': A<i32>(T) -> A<T>
1411     [46; 50) 'A(1)': A<i32>
1412     [48; 49) '1': i32
1413     [60; 64) 'A(n)': A<i32>
1414     [62; 63) 'n': &mut i32
1415     [67; 76) '&mut A(1)': &mut A<i32>
1416     [72; 73) 'A': A<i32>(T) -> A<T>
1417     [72; 76) 'A(1)': A<i32>
1418     [74; 75) '1': i32
1419     "###
1420     );
1421 }
1422
1423 #[test]
1424 fn infer_pattern_match_ergonomics_ref() {
1425     covers!(match_ergonomics_ref);
1426     assert_snapshot!(
1427         infer(r#"
1428 fn test() {
1429     let v = &(1, &2);
1430     let (_, &w) = v;
1431 }
1432 "#),
1433     @r###"
1434     [11; 57) '{     ...= v; }': ()
1435     [21; 22) 'v': &(i32, &i32)
1436     [25; 33) '&(1, &2)': &(i32, &i32)
1437     [26; 33) '(1, &2)': (i32, &i32)
1438     [27; 28) '1': i32
1439     [30; 32) '&2': &i32
1440     [31; 32) '2': i32
1441     [43; 50) '(_, &w)': (i32, &i32)
1442     [44; 45) '_': i32
1443     [47; 49) '&w': &i32
1444     [48; 49) 'w': i32
1445     [53; 54) 'v': &(i32, &i32)
1446     "###
1447     );
1448 }
1449
1450 #[test]
1451 fn infer_adt_pattern() {
1452     assert_snapshot!(
1453         infer(r#"
1454 enum E {
1455     A { x: usize },
1456     B
1457 }
1458
1459 struct S(u32, E);
1460
1461 fn test() {
1462     let e = E::A { x: 3 };
1463
1464     let S(y, z) = foo;
1465     let E::A { x: new_var } = e;
1466
1467     match e {
1468         E::A { x } => x,
1469         E::B if foo => 1,
1470         E::B => 10,
1471     };
1472
1473     let ref d @ E::A { .. } = e;
1474     d;
1475 }
1476 "#),
1477         @r###"
1478     [68; 289) '{     ...  d; }': ()
1479     [78; 79) 'e': E
1480     [82; 95) 'E::A { x: 3 }': E
1481     [92; 93) '3': usize
1482     [106; 113) 'S(y, z)': S
1483     [108; 109) 'y': u32
1484     [111; 112) 'z': E
1485     [116; 119) 'foo': S
1486     [129; 148) 'E::A {..._var }': E
1487     [139; 146) 'new_var': usize
1488     [151; 152) 'e': E
1489     [159; 245) 'match ...     }': usize
1490     [165; 166) 'e': E
1491     [177; 187) 'E::A { x }': E
1492     [184; 185) 'x': usize
1493     [191; 192) 'x': usize
1494     [202; 206) 'E::B': E
1495     [210; 213) 'foo': bool
1496     [217; 218) '1': usize
1497     [228; 232) 'E::B': E
1498     [236; 238) '10': usize
1499     [256; 275) 'ref d ...{ .. }': &E
1500     [264; 275) 'E::A { .. }': E
1501     [278; 279) 'e': E
1502     [285; 286) 'd': &E
1503     "###
1504     );
1505 }
1506
1507 #[test]
1508 fn infer_struct_generics() {
1509     assert_snapshot!(
1510         infer(r#"
1511 struct A<T> {
1512     x: T,
1513 }
1514
1515 fn test(a1: A<u32>, i: i32) {
1516     a1.x;
1517     let a2 = A { x: i };
1518     a2.x;
1519     let a3 = A::<i128> { x: 1 };
1520     a3.x;
1521 }
1522 "#),
1523         @r###"
1524     [36; 38) 'a1': A<u32>
1525     [48; 49) 'i': i32
1526     [56; 147) '{     ...3.x; }': ()
1527     [62; 64) 'a1': A<u32>
1528     [62; 66) 'a1.x': u32
1529     [76; 78) 'a2': A<i32>
1530     [81; 91) 'A { x: i }': A<i32>
1531     [88; 89) 'i': i32
1532     [97; 99) 'a2': A<i32>
1533     [97; 101) 'a2.x': i32
1534     [111; 113) 'a3': A<i128>
1535     [116; 134) 'A::<i1...x: 1 }': A<i128>
1536     [131; 132) '1': i128
1537     [140; 142) 'a3': A<i128>
1538     [140; 144) 'a3.x': i128
1539     "###
1540     );
1541 }
1542
1543 #[test]
1544 fn infer_tuple_struct_generics() {
1545     assert_snapshot!(
1546         infer(r#"
1547 struct A<T>(T);
1548 enum Option<T> { Some(T), None }
1549 use Option::*;
1550
1551 fn test() {
1552     A(42);
1553     A(42u128);
1554     Some("x");
1555     Option::Some("x");
1556     None;
1557     let x: Option<i64> = None;
1558 }
1559 "#),
1560         @r###"
1561     [76; 184) '{     ...one; }': ()
1562     [82; 83) 'A': A<i32>(T) -> A<T>
1563     [82; 87) 'A(42)': A<i32>
1564     [84; 86) '42': i32
1565     [93; 94) 'A': A<u128>(T) -> A<T>
1566     [93; 102) 'A(42u128)': A<u128>
1567     [95; 101) '42u128': u128
1568     [108; 112) 'Some': Some<&str>(T) -> Option<T>
1569     [108; 117) 'Some("x")': Option<&str>
1570     [113; 116) '"x"': &str
1571     [123; 135) 'Option::Some': Some<&str>(T) -> Option<T>
1572     [123; 140) 'Option...e("x")': Option<&str>
1573     [136; 139) '"x"': &str
1574     [146; 150) 'None': Option<{unknown}>
1575     [160; 161) 'x': Option<i64>
1576     [177; 181) 'None': Option<i64>
1577     "###
1578     );
1579 }
1580
1581 #[test]
1582 fn infer_generics_in_patterns() {
1583     assert_snapshot!(
1584         infer(r#"
1585 struct A<T> {
1586     x: T,
1587 }
1588
1589 enum Option<T> {
1590     Some(T),
1591     None,
1592 }
1593
1594 fn test(a1: A<u32>, o: Option<u64>) {
1595     let A { x: x2 } = a1;
1596     let A::<i64> { x: x3 } = A { x: 1 };
1597     match o {
1598         Option::Some(t) => t,
1599         _ => 1,
1600     };
1601 }
1602 "#),
1603         @r###"
1604     [79; 81) 'a1': A<u32>
1605     [91; 92) 'o': Option<u64>
1606     [107; 244) '{     ...  }; }': ()
1607     [117; 128) 'A { x: x2 }': A<u32>
1608     [124; 126) 'x2': u32
1609     [131; 133) 'a1': A<u32>
1610     [143; 161) 'A::<i6...: x3 }': A<i64>
1611     [157; 159) 'x3': i64
1612     [164; 174) 'A { x: 1 }': A<i64>
1613     [171; 172) '1': i64
1614     [180; 241) 'match ...     }': u64
1615     [186; 187) 'o': Option<u64>
1616     [198; 213) 'Option::Some(t)': Option<u64>
1617     [211; 212) 't': u64
1618     [217; 218) 't': u64
1619     [228; 229) '_': Option<u64>
1620     [233; 234) '1': u64
1621     "###
1622     );
1623 }
1624
1625 #[test]
1626 fn infer_function_generics() {
1627     assert_snapshot!(
1628         infer(r#"
1629 fn id<T>(t: T) -> T { t }
1630
1631 fn test() {
1632     id(1u32);
1633     id::<i128>(1);
1634     let x: u64 = id(1);
1635 }
1636 "#),
1637         @r###"
1638     [10; 11) 't': T
1639     [21; 26) '{ t }': T
1640     [23; 24) 't': T
1641     [38; 98) '{     ...(1); }': ()
1642     [44; 46) 'id': fn id<u32>(T) -> T
1643     [44; 52) 'id(1u32)': u32
1644     [47; 51) '1u32': u32
1645     [58; 68) 'id::<i128>': fn id<i128>(T) -> T
1646     [58; 71) 'id::<i128>(1)': i128
1647     [69; 70) '1': i128
1648     [81; 82) 'x': u64
1649     [90; 92) 'id': fn id<u64>(T) -> T
1650     [90; 95) 'id(1)': u64
1651     [93; 94) '1': u64
1652     "###
1653     );
1654 }
1655
1656 #[test]
1657 fn infer_impl_generics() {
1658     assert_snapshot!(
1659         infer(r#"
1660 struct A<T1, T2> {
1661     x: T1,
1662     y: T2,
1663 }
1664 impl<Y, X> A<X, Y> {
1665     fn x(self) -> X {
1666         self.x
1667     }
1668     fn y(self) -> Y {
1669         self.y
1670     }
1671     fn z<T>(self, t: T) -> (X, Y, T) {
1672         (self.x, self.y, t)
1673     }
1674 }
1675
1676 fn test() -> i128 {
1677     let a = A { x: 1u64, y: 1i64 };
1678     a.x();
1679     a.y();
1680     a.z(1i128);
1681     a.z::<u128>(1);
1682 }
1683 "#),
1684         @r###"
1685     [74; 78) 'self': A<X, Y>
1686     [85; 107) '{     ...     }': X
1687     [95; 99) 'self': A<X, Y>
1688     [95; 101) 'self.x': X
1689     [117; 121) 'self': A<X, Y>
1690     [128; 150) '{     ...     }': Y
1691     [138; 142) 'self': A<X, Y>
1692     [138; 144) 'self.y': Y
1693     [163; 167) 'self': A<X, Y>
1694     [169; 170) 't': T
1695     [188; 223) '{     ...     }': (X, Y, T)
1696     [198; 217) '(self.....y, t)': (X, Y, T)
1697     [199; 203) 'self': A<X, Y>
1698     [199; 205) 'self.x': X
1699     [207; 211) 'self': A<X, Y>
1700     [207; 213) 'self.y': Y
1701     [215; 216) 't': T
1702     [245; 342) '{     ...(1); }': ()
1703     [255; 256) 'a': A<u64, i64>
1704     [259; 281) 'A { x:...1i64 }': A<u64, i64>
1705     [266; 270) '1u64': u64
1706     [275; 279) '1i64': i64
1707     [287; 288) 'a': A<u64, i64>
1708     [287; 292) 'a.x()': u64
1709     [298; 299) 'a': A<u64, i64>
1710     [298; 303) 'a.y()': i64
1711     [309; 310) 'a': A<u64, i64>
1712     [309; 319) 'a.z(1i128)': (u64, i64, i128)
1713     [313; 318) '1i128': i128
1714     [325; 326) 'a': A<u64, i64>
1715     [325; 339) 'a.z::<u128>(1)': (u64, i64, u128)
1716     [337; 338) '1': u128
1717     "###
1718     );
1719 }
1720
1721 #[test]
1722 fn infer_impl_generics_with_autoderef() {
1723     assert_snapshot!(
1724         infer(r#"
1725 enum Option<T> {
1726     Some(T),
1727     None,
1728 }
1729 impl<T> Option<T> {
1730     fn as_ref(&self) -> Option<&T> {}
1731 }
1732 fn test(o: Option<u32>) {
1733     (&o).as_ref();
1734     o.as_ref();
1735 }
1736 "#),
1737         @r###"
1738     [78; 82) 'self': &Option<T>
1739     [98; 100) '{}': ()
1740     [111; 112) 'o': Option<u32>
1741     [127; 165) '{     ...f(); }': ()
1742     [133; 146) '(&o).as_ref()': Option<&u32>
1743     [134; 136) '&o': &Option<u32>
1744     [135; 136) 'o': Option<u32>
1745     [152; 153) 'o': Option<u32>
1746     [152; 162) 'o.as_ref()': Option<&u32>
1747     "###
1748     );
1749 }
1750
1751 #[test]
1752 fn infer_generic_chain() {
1753     assert_snapshot!(
1754         infer(r#"
1755 struct A<T> {
1756     x: T,
1757 }
1758 impl<T2> A<T2> {
1759     fn x(self) -> T2 {
1760         self.x
1761     }
1762 }
1763 fn id<T>(t: T) -> T { t }
1764
1765 fn test() -> i128 {
1766      let x = 1;
1767      let y = id(x);
1768      let a = A { x: id(y) };
1769      let z = id(a.x);
1770      let b = A { x: z };
1771      b.x()
1772 }
1773 "#),
1774         @r###"
1775     [53; 57) 'self': A<T2>
1776     [65; 87) '{     ...     }': T2
1777     [75; 79) 'self': A<T2>
1778     [75; 81) 'self.x': T2
1779     [99; 100) 't': T
1780     [110; 115) '{ t }': T
1781     [112; 113) 't': T
1782     [135; 261) '{     ....x() }': i128
1783     [146; 147) 'x': i128
1784     [150; 151) '1': i128
1785     [162; 163) 'y': i128
1786     [166; 168) 'id': fn id<i128>(T) -> T
1787     [166; 171) 'id(x)': i128
1788     [169; 170) 'x': i128
1789     [182; 183) 'a': A<i128>
1790     [186; 200) 'A { x: id(y) }': A<i128>
1791     [193; 195) 'id': fn id<i128>(T) -> T
1792     [193; 198) 'id(y)': i128
1793     [196; 197) 'y': i128
1794     [211; 212) 'z': i128
1795     [215; 217) 'id': fn id<i128>(T) -> T
1796     [215; 222) 'id(a.x)': i128
1797     [218; 219) 'a': A<i128>
1798     [218; 221) 'a.x': i128
1799     [233; 234) 'b': A<i128>
1800     [237; 247) 'A { x: z }': A<i128>
1801     [244; 245) 'z': i128
1802     [254; 255) 'b': A<i128>
1803     [254; 259) 'b.x()': i128
1804     "###
1805     );
1806 }
1807
1808 #[test]
1809 fn infer_associated_const() {
1810     assert_snapshot!(
1811         infer(r#"
1812 struct Struct;
1813
1814 impl Struct {
1815     const FOO: u32 = 1;
1816 }
1817
1818 enum Enum {}
1819
1820 impl Enum {
1821     const BAR: u32 = 2;
1822 }
1823
1824 trait Trait {
1825     const ID: u32;
1826 }
1827
1828 struct TraitTest;
1829
1830 impl Trait for TraitTest {
1831     const ID: u32 = 5;
1832 }
1833
1834 fn test() {
1835     let x = Struct::FOO;
1836     let y = Enum::BAR;
1837     let z = TraitTest::ID;
1838 }
1839 "#),
1840         @r###"
1841     [52; 53) '1': u32
1842     [105; 106) '2': u32
1843     [213; 214) '5': u32
1844     [229; 307) '{     ...:ID; }': ()
1845     [239; 240) 'x': u32
1846     [243; 254) 'Struct::FOO': u32
1847     [264; 265) 'y': u32
1848     [268; 277) 'Enum::BAR': u32
1849     [287; 288) 'z': u32
1850     [291; 304) 'TraitTest::ID': u32
1851     "###
1852     );
1853 }
1854
1855 #[test]
1856 fn infer_associated_method_struct() {
1857     assert_snapshot!(
1858         infer(r#"
1859 struct A { x: u32 }
1860
1861 impl A {
1862     fn new() -> A {
1863         A { x: 0 }
1864     }
1865 }
1866 fn test() {
1867     let a = A::new();
1868     a.x;
1869 }
1870 "#),
1871         @r###"
1872     [49; 75) '{     ...     }': A
1873     [59; 69) 'A { x: 0 }': A
1874     [66; 67) '0': u32
1875     [88; 122) '{     ...a.x; }': ()
1876     [98; 99) 'a': A
1877     [102; 108) 'A::new': fn new() -> A
1878     [102; 110) 'A::new()': A
1879     [116; 117) 'a': A
1880     [116; 119) 'a.x': u32
1881     "###
1882     );
1883 }
1884
1885 #[test]
1886 fn infer_associated_method_enum() {
1887     assert_snapshot!(
1888         infer(r#"
1889 enum A { B, C }
1890
1891 impl A {
1892     pub fn b() -> A {
1893         A::B
1894     }
1895     pub fn c() -> A {
1896         A::C
1897     }
1898 }
1899 fn test() {
1900     let a = A::b();
1901     a;
1902     let c = A::c();
1903     c;
1904 }
1905 "#),
1906         @r###"
1907     [47; 67) '{     ...     }': A
1908     [57; 61) 'A::B': A
1909     [88; 108) '{     ...     }': A
1910     [98; 102) 'A::C': A
1911     [121; 178) '{     ...  c; }': ()
1912     [131; 132) 'a': A
1913     [135; 139) 'A::b': fn b() -> A
1914     [135; 141) 'A::b()': A
1915     [147; 148) 'a': A
1916     [158; 159) 'c': A
1917     [162; 166) 'A::c': fn c() -> A
1918     [162; 168) 'A::c()': A
1919     [174; 175) 'c': A
1920     "###
1921     );
1922 }
1923
1924 #[test]
1925 fn infer_associated_method_with_modules() {
1926     assert_snapshot!(
1927         infer(r#"
1928 mod a {
1929     struct A;
1930     impl A { pub fn thing() -> A { A {} }}
1931 }
1932
1933 mod b {
1934     struct B;
1935     impl B { pub fn thing() -> u32 { 99 }}
1936
1937     mod c {
1938         struct C;
1939         impl C { pub fn thing() -> C { C {} }}
1940     }
1941 }
1942 use b::c;
1943
1944 fn test() {
1945     let x = a::A::thing();
1946     let y = b::B::thing();
1947     let z = c::C::thing();
1948 }
1949 "#),
1950         @r###"
1951     [56; 64) '{ A {} }': A
1952     [58; 62) 'A {}': A
1953     [126; 132) '{ 99 }': u32
1954     [128; 130) '99': u32
1955     [202; 210) '{ C {} }': C
1956     [204; 208) 'C {}': C
1957     [241; 325) '{     ...g(); }': ()
1958     [251; 252) 'x': A
1959     [255; 266) 'a::A::thing': fn thing() -> A
1960     [255; 268) 'a::A::thing()': A
1961     [278; 279) 'y': u32
1962     [282; 293) 'b::B::thing': fn thing() -> u32
1963     [282; 295) 'b::B::thing()': u32
1964     [305; 306) 'z': C
1965     [309; 320) 'c::C::thing': fn thing() -> C
1966     [309; 322) 'c::C::thing()': C
1967     "###
1968     );
1969 }
1970
1971 #[test]
1972 fn infer_associated_method_generics() {
1973     assert_snapshot!(
1974         infer(r#"
1975 struct Gen<T> {
1976     val: T
1977 }
1978
1979 impl<T> Gen<T> {
1980     pub fn make(val: T) -> Gen<T> {
1981         Gen { val }
1982     }
1983 }
1984
1985 fn test() {
1986     let a = Gen::make(0u32);
1987 }
1988 "#),
1989         @r###"
1990     [64; 67) 'val': T
1991     [82; 109) '{     ...     }': Gen<T>
1992     [92; 103) 'Gen { val }': Gen<T>
1993     [98; 101) 'val': T
1994     [123; 155) '{     ...32); }': ()
1995     [133; 134) 'a': Gen<u32>
1996     [137; 146) 'Gen::make': fn make<u32>(T) -> Gen<T>
1997     [137; 152) 'Gen::make(0u32)': Gen<u32>
1998     [147; 151) '0u32': u32
1999     "###
2000     );
2001 }
2002
2003 #[test]
2004 fn infer_associated_method_generics_with_default_param() {
2005     assert_snapshot!(
2006         infer(r#"
2007 struct Gen<T=u32> {
2008     val: T
2009 }
2010
2011 impl<T> Gen<T> {
2012     pub fn make() -> Gen<T> {
2013         loop { }
2014     }
2015 }
2016
2017 fn test() {
2018     let a = Gen::make();
2019 }
2020 "#),
2021         @r###"
2022     [80; 104) '{     ...     }': Gen<T>
2023     [90; 98) 'loop { }': !
2024     [95; 98) '{ }': ()
2025     [118; 146) '{     ...e(); }': ()
2026     [128; 129) 'a': Gen<u32>
2027     [132; 141) 'Gen::make': fn make<u32>() -> Gen<T>
2028     [132; 143) 'Gen::make()': Gen<u32>
2029     "###
2030     );
2031 }
2032
2033 #[test]
2034 fn infer_associated_method_generics_with_default_tuple_param() {
2035     let t = type_at(
2036         r#"
2037 //- /main.rs
2038 struct Gen<T=()> {
2039     val: T
2040 }
2041
2042 impl<T> Gen<T> {
2043     pub fn make() -> Gen<T> {
2044         loop { }
2045     }
2046 }
2047
2048 fn test() {
2049     let a = Gen::make();
2050     a.val<|>;
2051 }
2052 "#,
2053     );
2054     assert_eq!(t, "()");
2055 }
2056
2057 #[test]
2058 fn infer_associated_method_generics_without_args() {
2059     assert_snapshot!(
2060         infer(r#"
2061 struct Gen<T> {
2062     val: T
2063 }
2064
2065 impl<T> Gen<T> {
2066     pub fn make() -> Gen<T> {
2067         loop { }
2068     }
2069 }
2070
2071 fn test() {
2072     let a = Gen::<u32>::make();
2073 }
2074 "#),
2075         @r###"
2076     [76; 100) '{     ...     }': Gen<T>
2077     [86; 94) 'loop { }': !
2078     [91; 94) '{ }': ()
2079     [114; 149) '{     ...e(); }': ()
2080     [124; 125) 'a': Gen<u32>
2081     [128; 144) 'Gen::<...::make': fn make<u32>() -> Gen<T>
2082     [128; 146) 'Gen::<...make()': Gen<u32>
2083     "###
2084     );
2085 }
2086
2087 #[test]
2088 fn infer_associated_method_generics_2_type_params_without_args() {
2089     assert_snapshot!(
2090         infer(r#"
2091 struct Gen<T, U> {
2092     val: T,
2093     val2: U,
2094 }
2095
2096 impl<T> Gen<u32, T> {
2097     pub fn make() -> Gen<u32,T> {
2098         loop { }
2099     }
2100 }
2101
2102 fn test() {
2103     let a = Gen::<u32, u64>::make();
2104 }
2105 "#),
2106         @r###"
2107     [102; 126) '{     ...     }': Gen<u32, T>
2108     [112; 120) 'loop { }': !
2109     [117; 120) '{ }': ()
2110     [140; 180) '{     ...e(); }': ()
2111     [150; 151) 'a': Gen<u32, u64>
2112     [154; 175) 'Gen::<...::make': fn make<u64>() -> Gen<u32, T>
2113     [154; 177) 'Gen::<...make()': Gen<u32, u64>
2114     "###
2115     );
2116 }
2117
2118 #[test]
2119 fn infer_type_alias() {
2120     assert_snapshot!(
2121         infer(r#"
2122 struct A<X, Y> { x: X, y: Y }
2123 type Foo = A<u32, i128>;
2124 type Bar<T> = A<T, u128>;
2125 type Baz<U, V> = A<V, U>;
2126 fn test(x: Foo, y: Bar<&str>, z: Baz<i8, u8>) {
2127     x.x;
2128     x.y;
2129     y.x;
2130     y.y;
2131     z.x;
2132     z.y;
2133 }
2134 "#),
2135         @r###"
2136     [116; 117) 'x': A<u32, i128>
2137     [124; 125) 'y': A<&str, u128>
2138     [138; 139) 'z': A<u8, i8>
2139     [154; 211) '{     ...z.y; }': ()
2140     [160; 161) 'x': A<u32, i128>
2141     [160; 163) 'x.x': u32
2142     [169; 170) 'x': A<u32, i128>
2143     [169; 172) 'x.y': i128
2144     [178; 179) 'y': A<&str, u128>
2145     [178; 181) 'y.x': &str
2146     [187; 188) 'y': A<&str, u128>
2147     [187; 190) 'y.y': u128
2148     [196; 197) 'z': A<u8, i8>
2149     [196; 199) 'z.x': u8
2150     [205; 206) 'z': A<u8, i8>
2151     [205; 208) 'z.y': i8
2152     "###
2153     )
2154 }
2155
2156 #[test]
2157 fn recursive_type_alias() {
2158     assert_snapshot!(
2159         infer(r#"
2160 struct A<X> {}
2161 type Foo = Foo;
2162 type Bar = A<Bar>;
2163 fn test(x: Foo) {}
2164 "#),
2165         @r###"
2166     [59; 60) 'x': {unknown}
2167     [67; 69) '{}': ()
2168     "###
2169     )
2170 }
2171
2172 #[test]
2173 fn no_panic_on_field_of_enum() {
2174     assert_snapshot!(
2175         infer(r#"
2176 enum X {}
2177
2178 fn test(x: X) {
2179     x.some_field;
2180 }
2181 "#),
2182         @r###"
2183     [20; 21) 'x': X
2184     [26; 47) '{     ...eld; }': ()
2185     [32; 33) 'x': X
2186     [32; 44) 'x.some_field': {unknown}
2187     "###
2188     );
2189 }
2190
2191 #[test]
2192 fn bug_585() {
2193     assert_snapshot!(
2194         infer(r#"
2195 fn test() {
2196     X {};
2197     match x {
2198         A::B {} => (),
2199         A::Y() => (),
2200     }
2201 }
2202 "#),
2203         @r###"
2204     [11; 89) '{     ...   } }': ()
2205     [17; 21) 'X {}': {unknown}
2206     [27; 87) 'match ...     }': ()
2207     [33; 34) 'x': {unknown}
2208     [45; 52) 'A::B {}': {unknown}
2209     [56; 58) '()': ()
2210     [68; 74) 'A::Y()': {unknown}
2211     [78; 80) '()': ()
2212     "###
2213     );
2214 }
2215
2216 #[test]
2217 fn bug_651() {
2218     assert_snapshot!(
2219         infer(r#"
2220 fn quux() {
2221     let y = 92;
2222     1 + y;
2223 }
2224 "#),
2225         @r###"
2226     [11; 41) '{     ...+ y; }': ()
2227     [21; 22) 'y': i32
2228     [25; 27) '92': i32
2229     [33; 34) '1': i32
2230     [33; 38) '1 + y': i32
2231     [37; 38) 'y': i32
2232     "###
2233     );
2234 }
2235
2236 #[test]
2237 fn recursive_vars() {
2238     covers!(type_var_cycles_resolve_completely);
2239     covers!(type_var_cycles_resolve_as_possible);
2240     assert_snapshot!(
2241         infer(r#"
2242 fn test() {
2243     let y = unknown;
2244     [y, &y];
2245 }
2246 "#),
2247         @r###"
2248     [11; 48) '{     ...&y]; }': ()
2249     [21; 22) 'y': &{unknown}
2250     [25; 32) 'unknown': &{unknown}
2251     [38; 45) '[y, &y]': [&&{unknown};_]
2252     [39; 40) 'y': &{unknown}
2253     [42; 44) '&y': &&{unknown}
2254     [43; 44) 'y': &{unknown}
2255     "###
2256     );
2257 }
2258
2259 #[test]
2260 fn recursive_vars_2() {
2261     covers!(type_var_cycles_resolve_completely);
2262     covers!(type_var_cycles_resolve_as_possible);
2263     assert_snapshot!(
2264         infer(r#"
2265 fn test() {
2266     let x = unknown;
2267     let y = unknown;
2268     [(x, y), (&y, &x)];
2269 }
2270 "#),
2271         @r###"
2272     [11; 80) '{     ...x)]; }': ()
2273     [21; 22) 'x': &&{unknown}
2274     [25; 32) 'unknown': &&{unknown}
2275     [42; 43) 'y': &&{unknown}
2276     [46; 53) 'unknown': &&{unknown}
2277     [59; 77) '[(x, y..., &x)]': [(&&&{unknown}, &&&{unknown});_]
2278     [60; 66) '(x, y)': (&&&{unknown}, &&&{unknown})
2279     [61; 62) 'x': &&{unknown}
2280     [64; 65) 'y': &&{unknown}
2281     [68; 76) '(&y, &x)': (&&&{unknown}, &&&{unknown})
2282     [69; 71) '&y': &&&{unknown}
2283     [70; 71) 'y': &&{unknown}
2284     [73; 75) '&x': &&&{unknown}
2285     [74; 75) 'x': &&{unknown}
2286     "###
2287     );
2288 }
2289
2290 #[test]
2291 fn infer_type_param() {
2292     assert_snapshot!(
2293         infer(r#"
2294 fn id<T>(x: T) -> T {
2295     x
2296 }
2297
2298 fn clone<T>(x: &T) -> T {
2299     *x
2300 }
2301
2302 fn test() {
2303     let y = 10u32;
2304     id(y);
2305     let x: bool = clone(z);
2306     id::<i128>(1);
2307 }
2308 "#),
2309         @r###"
2310     [10; 11) 'x': T
2311     [21; 30) '{     x }': T
2312     [27; 28) 'x': T
2313     [44; 45) 'x': &T
2314     [56; 66) '{     *x }': T
2315     [62; 64) '*x': T
2316     [63; 64) 'x': &T
2317     [78; 158) '{     ...(1); }': ()
2318     [88; 89) 'y': u32
2319     [92; 97) '10u32': u32
2320     [103; 105) 'id': fn id<u32>(T) -> T
2321     [103; 108) 'id(y)': u32
2322     [106; 107) 'y': u32
2323     [118; 119) 'x': bool
2324     [128; 133) 'clone': fn clone<bool>(&T) -> T
2325     [128; 136) 'clone(z)': bool
2326     [134; 135) 'z': &bool
2327     [142; 152) 'id::<i128>': fn id<i128>(T) -> T
2328     [142; 155) 'id::<i128>(1)': i128
2329     [153; 154) '1': i128
2330     "###
2331     );
2332 }
2333
2334 #[test]
2335 fn infer_std_crash_1() {
2336     // caused stack overflow, taken from std
2337     assert_snapshot!(
2338         infer(r#"
2339 enum Maybe<T> {
2340     Real(T),
2341     Fake,
2342 }
2343
2344 fn write() {
2345     match something_unknown {
2346         Maybe::Real(ref mut something) => (),
2347     }
2348 }
2349 "#),
2350         @r###"
2351     [54; 139) '{     ...   } }': ()
2352     [60; 137) 'match ...     }': ()
2353     [66; 83) 'someth...nknown': Maybe<{unknown}>
2354     [94; 124) 'Maybe:...thing)': Maybe<{unknown}>
2355     [106; 123) 'ref mu...ething': &mut {unknown}
2356     [128; 130) '()': ()
2357     "###
2358     );
2359 }
2360
2361 #[test]
2362 fn infer_std_crash_2() {
2363     covers!(type_var_resolves_to_int_var);
2364     // caused "equating two type variables, ...", taken from std
2365     assert_snapshot!(
2366         infer(r#"
2367 fn test_line_buffer() {
2368     &[0, b'\n', 1, b'\n'];
2369 }
2370 "#),
2371         @r###"
2372     [23; 53) '{     ...n']; }': ()
2373     [29; 50) '&[0, b...b'\n']': &[u8;_]
2374     [30; 50) '[0, b'...b'\n']': [u8;_]
2375     [31; 32) '0': u8
2376     [34; 39) 'b'\n'': u8
2377     [41; 42) '1': u8
2378     [44; 49) 'b'\n'': u8
2379     "###
2380     );
2381 }
2382
2383 #[test]
2384 fn infer_std_crash_3() {
2385     // taken from rustc
2386     assert_snapshot!(
2387         infer(r#"
2388 pub fn compute() {
2389     match nope!() {
2390         SizeSkeleton::Pointer { non_zero: true, tail } => {}
2391     }
2392 }
2393 "#),
2394         @r###"
2395     [18; 108) '{     ...   } }': ()
2396     [24; 106) 'match ...     }': ()
2397     [30; 37) 'nope!()': {unknown}
2398     [48; 94) 'SizeSk...tail }': {unknown}
2399     [82; 86) 'true': {unknown}
2400     [88; 92) 'tail': {unknown}
2401     [98; 100) '{}': ()
2402     "###
2403     );
2404 }
2405
2406 #[test]
2407 fn infer_std_crash_4() {
2408     // taken from rustc
2409     assert_snapshot!(
2410         infer(r#"
2411 pub fn primitive_type() {
2412     match *self {
2413         BorrowedRef { type_: Primitive(p), ..} => {},
2414     }
2415 }
2416 "#),
2417         @r###"
2418     [25; 106) '{     ...   } }': ()
2419     [31; 104) 'match ...     }': ()
2420     [37; 42) '*self': {unknown}
2421     [38; 42) 'self': {unknown}
2422     [53; 91) 'Borrow...), ..}': {unknown}
2423     [74; 86) 'Primitive(p)': {unknown}
2424     [84; 85) 'p': {unknown}
2425     [95; 97) '{}': ()
2426     "###
2427     );
2428 }
2429
2430 #[test]
2431 fn infer_std_crash_5() {
2432     // taken from rustc
2433     assert_snapshot!(
2434         infer(r#"
2435 fn extra_compiler_flags() {
2436     for content in doesnt_matter {
2437         let name = if doesnt_matter {
2438             first
2439         } else {
2440             &content
2441         };
2442
2443         let content = if ICE_REPORT_COMPILER_FLAGS_STRIP_VALUE.contains(&name) {
2444             name
2445         } else {
2446             content
2447         };
2448     }
2449 }
2450 "#),
2451         @r###"
2452     [27; 323) '{     ...   } }': ()
2453     [33; 321) 'for co...     }': ()
2454     [37; 44) 'content': &{unknown}
2455     [48; 61) 'doesnt_matter': {unknown}
2456     [62; 321) '{     ...     }': ()
2457     [76; 80) 'name': &&{unknown}
2458     [83; 167) 'if doe...     }': &&{unknown}
2459     [86; 99) 'doesnt_matter': bool
2460     [100; 129) '{     ...     }': &&{unknown}
2461     [114; 119) 'first': &&{unknown}
2462     [135; 167) '{     ...     }': &&{unknown}
2463     [149; 157) '&content': &&{unknown}
2464     [150; 157) 'content': &{unknown}
2465     [182; 189) 'content': &{unknown}
2466     [192; 314) 'if ICE...     }': &{unknown}
2467     [195; 232) 'ICE_RE..._VALUE': {unknown}
2468     [195; 248) 'ICE_RE...&name)': bool
2469     [242; 247) '&name': &&&{unknown}
2470     [243; 247) 'name': &&{unknown}
2471     [249; 277) '{     ...     }': &&{unknown}
2472     [263; 267) 'name': &&{unknown}
2473     [283; 314) '{     ...     }': &{unknown}
2474     [297; 304) 'content': &{unknown}
2475     "###
2476     );
2477 }
2478
2479 #[test]
2480 fn infer_nested_generics_crash() {
2481     // another crash found typechecking rustc
2482     assert_snapshot!(
2483         infer(r#"
2484 struct Canonical<V> {
2485     value: V,
2486 }
2487 struct QueryResponse<V> {
2488     value: V,
2489 }
2490 fn test<R>(query_response: Canonical<QueryResponse<R>>) {
2491     &query_response.value;
2492 }
2493 "#),
2494         @r###"
2495     [92; 106) 'query_response': Canonical<QueryResponse<R>>
2496     [137; 167) '{     ...lue; }': ()
2497     [143; 164) '&query....value': &QueryResponse<R>
2498     [144; 158) 'query_response': Canonical<QueryResponse<R>>
2499     [144; 164) 'query_....value': QueryResponse<R>
2500     "###
2501     );
2502 }
2503
2504 #[test]
2505 fn bug_1030() {
2506     assert_snapshot!(infer(r#"
2507 struct HashSet<T, H>;
2508 struct FxHasher;
2509 type FxHashSet<T> = HashSet<T, FxHasher>;
2510
2511 impl<T, H> HashSet<T, H> {
2512     fn default() -> HashSet<T, H> {}
2513 }
2514
2515 pub fn main_loop() {
2516     FxHashSet::default();
2517 }
2518 "#),
2519     @r###"
2520     [144; 146) '{}': ()
2521     [169; 198) '{     ...t(); }': ()
2522     [175; 193) 'FxHash...efault': fn default<{unknown}, FxHasher>() -> HashSet<T, H>
2523     [175; 195) 'FxHash...ault()': HashSet<{unknown}, FxHasher>
2524     "###
2525     );
2526 }
2527
2528 #[test]
2529 fn cross_crate_associated_method_call() {
2530     let (db, pos) = TestDB::with_position(
2531         r#"
2532 //- /main.rs crate:main deps:other_crate
2533 fn test() {
2534     let x = other_crate::foo::S::thing();
2535     x<|>;
2536 }
2537
2538 //- /lib.rs crate:other_crate
2539 mod foo {
2540     struct S;
2541     impl S {
2542         fn thing() -> i128 {}
2543     }
2544 }
2545 "#,
2546     );
2547     assert_eq!("i128", type_at_pos(&db, pos));
2548 }
2549
2550 #[test]
2551 fn infer_const() {
2552     assert_snapshot!(
2553         infer(r#"
2554 struct Foo;
2555 impl Foo { const ASSOC_CONST: u32 = 0; }
2556 const GLOBAL_CONST: u32 = 101;
2557 fn test() {
2558     const LOCAL_CONST: u32 = 99;
2559     let x = LOCAL_CONST;
2560     let z = GLOBAL_CONST;
2561     let id = Foo::ASSOC_CONST;
2562 }
2563 "#),
2564         @r###"
2565     [49; 50) '0': u32
2566     [80; 83) '101': u32
2567     [95; 213) '{     ...NST; }': ()
2568     [138; 139) 'x': {unknown}
2569     [142; 153) 'LOCAL_CONST': {unknown}
2570     [163; 164) 'z': u32
2571     [167; 179) 'GLOBAL_CONST': u32
2572     [189; 191) 'id': u32
2573     [194; 210) 'Foo::A..._CONST': u32
2574     "###
2575     );
2576 }
2577
2578 #[test]
2579 fn infer_static() {
2580     assert_snapshot!(
2581         infer(r#"
2582 static GLOBAL_STATIC: u32 = 101;
2583 static mut GLOBAL_STATIC_MUT: u32 = 101;
2584 fn test() {
2585     static LOCAL_STATIC: u32 = 99;
2586     static mut LOCAL_STATIC_MUT: u32 = 99;
2587     let x = LOCAL_STATIC;
2588     let y = LOCAL_STATIC_MUT;
2589     let z = GLOBAL_STATIC;
2590     let w = GLOBAL_STATIC_MUT;
2591 }
2592 "#),
2593         @r###"
2594     [29; 32) '101': u32
2595     [70; 73) '101': u32
2596     [85; 280) '{     ...MUT; }': ()
2597     [173; 174) 'x': {unknown}
2598     [177; 189) 'LOCAL_STATIC': {unknown}
2599     [199; 200) 'y': {unknown}
2600     [203; 219) 'LOCAL_...IC_MUT': {unknown}
2601     [229; 230) 'z': u32
2602     [233; 246) 'GLOBAL_STATIC': u32
2603     [256; 257) 'w': u32
2604     [260; 277) 'GLOBAL...IC_MUT': u32
2605     "###
2606     );
2607 }
2608
2609 #[test]
2610 fn infer_trait_method_simple() {
2611     // the trait implementation is intentionally incomplete -- it shouldn't matter
2612     assert_snapshot!(
2613         infer(r#"
2614 trait Trait1 {
2615     fn method(&self) -> u32;
2616 }
2617 struct S1;
2618 impl Trait1 for S1 {}
2619 trait Trait2 {
2620     fn method(&self) -> i128;
2621 }
2622 struct S2;
2623 impl Trait2 for S2 {}
2624 fn test() {
2625     S1.method(); // -> u32
2626     S2.method(); // -> i128
2627 }
2628 "#),
2629         @r###"
2630     [31; 35) 'self': &Self
2631     [110; 114) 'self': &Self
2632     [170; 228) '{     ...i128 }': ()
2633     [176; 178) 'S1': S1
2634     [176; 187) 'S1.method()': u32
2635     [203; 205) 'S2': S2
2636     [203; 214) 'S2.method()': i128
2637     "###
2638     );
2639 }
2640
2641 #[test]
2642 fn infer_trait_method_scoped() {
2643     // the trait implementation is intentionally incomplete -- it shouldn't matter
2644     assert_snapshot!(
2645         infer(r#"
2646 struct S;
2647 mod foo {
2648     pub trait Trait1 {
2649         fn method(&self) -> u32;
2650     }
2651     impl Trait1 for super::S {}
2652 }
2653 mod bar {
2654     pub trait Trait2 {
2655         fn method(&self) -> i128;
2656     }
2657     impl Trait2 for super::S {}
2658 }
2659
2660 mod foo_test {
2661     use super::S;
2662     use super::foo::Trait1;
2663     fn test() {
2664         S.method(); // -> u32
2665     }
2666 }
2667
2668 mod bar_test {
2669     use super::S;
2670     use super::bar::Trait2;
2671     fn test() {
2672         S.method(); // -> i128
2673     }
2674 }
2675 "#),
2676         @r###"
2677     [63; 67) 'self': &Self
2678     [169; 173) 'self': &Self
2679     [300; 337) '{     ...     }': ()
2680     [310; 311) 'S': S
2681     [310; 320) 'S.method()': u32
2682     [416; 454) '{     ...     }': ()
2683     [426; 427) 'S': S
2684     [426; 436) 'S.method()': i128
2685     "###
2686     );
2687 }
2688
2689 #[test]
2690 fn infer_trait_method_generic_1() {
2691     // the trait implementation is intentionally incomplete -- it shouldn't matter
2692     assert_snapshot!(
2693         infer(r#"
2694 trait Trait<T> {
2695     fn method(&self) -> T;
2696 }
2697 struct S;
2698 impl Trait<u32> for S {}
2699 fn test() {
2700     S.method();
2701 }
2702 "#),
2703         @r###"
2704     [33; 37) 'self': &Self
2705     [92; 111) '{     ...d(); }': ()
2706     [98; 99) 'S': S
2707     [98; 108) 'S.method()': u32
2708     "###
2709     );
2710 }
2711
2712 #[test]
2713 fn infer_trait_method_generic_more_params() {
2714     // the trait implementation is intentionally incomplete -- it shouldn't matter
2715     assert_snapshot!(
2716         infer(r#"
2717 trait Trait<T1, T2, T3> {
2718     fn method1(&self) -> (T1, T2, T3);
2719     fn method2(&self) -> (T3, T2, T1);
2720 }
2721 struct S1;
2722 impl Trait<u8, u16, u32> for S1 {}
2723 struct S2;
2724 impl<T> Trait<i8, i16, T> for S2 {}
2725 fn test() {
2726     S1.method1(); // u8, u16, u32
2727     S1.method2(); // u32, u16, u8
2728     S2.method1(); // i8, i16, {unknown}
2729     S2.method2(); // {unknown}, i16, i8
2730 }
2731 "#),
2732         @r###"
2733     [43; 47) 'self': &Self
2734     [82; 86) 'self': &Self
2735     [210; 361) '{     ..., i8 }': ()
2736     [216; 218) 'S1': S1
2737     [216; 228) 'S1.method1()': (u8, u16, u32)
2738     [250; 252) 'S1': S1
2739     [250; 262) 'S1.method2()': (u32, u16, u8)
2740     [284; 286) 'S2': S2
2741     [284; 296) 'S2.method1()': (i8, i16, {unknown})
2742     [324; 326) 'S2': S2
2743     [324; 336) 'S2.method2()': ({unknown}, i16, i8)
2744     "###
2745     );
2746 }
2747
2748 #[test]
2749 fn infer_trait_method_generic_2() {
2750     // the trait implementation is intentionally incomplete -- it shouldn't matter
2751     assert_snapshot!(
2752         infer(r#"
2753 trait Trait<T> {
2754     fn method(&self) -> T;
2755 }
2756 struct S<T>(T);
2757 impl<U> Trait<U> for S<U> {}
2758 fn test() {
2759     S(1u32).method();
2760 }
2761 "#),
2762         @r###"
2763     [33; 37) 'self': &Self
2764     [102; 127) '{     ...d(); }': ()
2765     [108; 109) 'S': S<u32>(T) -> S<T>
2766     [108; 115) 'S(1u32)': S<u32>
2767     [108; 124) 'S(1u32...thod()': u32
2768     [110; 114) '1u32': u32
2769     "###
2770     );
2771 }
2772
2773 #[test]
2774 fn infer_trait_assoc_method() {
2775     assert_snapshot!(
2776         infer(r#"
2777 trait Default {
2778     fn default() -> Self;
2779 }
2780 struct S;
2781 impl Default for S {}
2782 fn test() {
2783     let s1: S = Default::default();
2784     let s2 = S::default();
2785     let s3 = <S as Default>::default();
2786 }
2787 "#),
2788         @r###"
2789     [87; 193) '{     ...t(); }': ()
2790     [97; 99) 's1': S
2791     [105; 121) 'Defaul...efault': fn default<S>() -> Self
2792     [105; 123) 'Defaul...ault()': S
2793     [133; 135) 's2': S
2794     [138; 148) 'S::default': fn default<S>() -> Self
2795     [138; 150) 'S::default()': S
2796     [160; 162) 's3': S
2797     [165; 188) '<S as ...efault': fn default<S>() -> Self
2798     [165; 190) '<S as ...ault()': S
2799     "###
2800     );
2801 }
2802
2803 #[test]
2804 fn infer_trait_assoc_method_generics_1() {
2805     assert_snapshot!(
2806         infer(r#"
2807 trait Trait<T> {
2808     fn make() -> T;
2809 }
2810 struct S;
2811 impl Trait<u32> for S {}
2812 struct G<T>;
2813 impl<T> Trait<T> for G<T> {}
2814 fn test() {
2815     let a = S::make();
2816     let b = G::<u64>::make();
2817     let c: f64 = G::make();
2818 }
2819 "#),
2820         @r###"
2821     [127; 211) '{     ...e(); }': ()
2822     [137; 138) 'a': u32
2823     [141; 148) 'S::make': fn make<S, u32>() -> T
2824     [141; 150) 'S::make()': u32
2825     [160; 161) 'b': u64
2826     [164; 178) 'G::<u64>::make': fn make<G<u64>, u64>() -> T
2827     [164; 180) 'G::<u6...make()': u64
2828     [190; 191) 'c': f64
2829     [199; 206) 'G::make': fn make<G<f64>, f64>() -> T
2830     [199; 208) 'G::make()': f64
2831     "###
2832     );
2833 }
2834
2835 #[test]
2836 fn infer_trait_assoc_method_generics_2() {
2837     assert_snapshot!(
2838         infer(r#"
2839 trait Trait<T> {
2840     fn make<U>() -> (T, U);
2841 }
2842 struct S;
2843 impl Trait<u32> for S {}
2844 struct G<T>;
2845 impl<T> Trait<T> for G<T> {}
2846 fn test() {
2847     let a = S::make::<i64>();
2848     let b: (_, i64) = S::make();
2849     let c = G::<u32>::make::<i64>();
2850     let d: (u32, _) = G::make::<i64>();
2851     let e: (u32, i64) = G::make();
2852 }
2853 "#),
2854         @r###"
2855     [135; 313) '{     ...e(); }': ()
2856     [145; 146) 'a': (u32, i64)
2857     [149; 163) 'S::make::<i64>': fn make<S, u32, i64>() -> (T, U)
2858     [149; 165) 'S::mak...i64>()': (u32, i64)
2859     [175; 176) 'b': (u32, i64)
2860     [189; 196) 'S::make': fn make<S, u32, i64>() -> (T, U)
2861     [189; 198) 'S::make()': (u32, i64)
2862     [208; 209) 'c': (u32, i64)
2863     [212; 233) 'G::<u3...:<i64>': fn make<G<u32>, u32, i64>() -> (T, U)
2864     [212; 235) 'G::<u3...i64>()': (u32, i64)
2865     [245; 246) 'd': (u32, i64)
2866     [259; 273) 'G::make::<i64>': fn make<G<u32>, u32, i64>() -> (T, U)
2867     [259; 275) 'G::mak...i64>()': (u32, i64)
2868     [285; 286) 'e': (u32, i64)
2869     [301; 308) 'G::make': fn make<G<u32>, u32, i64>() -> (T, U)
2870     [301; 310) 'G::make()': (u32, i64)
2871     "###
2872     );
2873 }
2874
2875 #[test]
2876 fn infer_trait_assoc_method_generics_3() {
2877     assert_snapshot!(
2878         infer(r#"
2879 trait Trait<T> {
2880     fn make() -> (Self, T);
2881 }
2882 struct S<T>;
2883 impl Trait<i64> for S<i32> {}
2884 fn test() {
2885     let a = S::make();
2886 }
2887 "#),
2888         @r###"
2889     [101; 127) '{     ...e(); }': ()
2890     [111; 112) 'a': (S<i32>, i64)
2891     [115; 122) 'S::make': fn make<S<i32>, i64>() -> (Self, T)
2892     [115; 124) 'S::make()': (S<i32>, i64)
2893     "###
2894     );
2895 }
2896
2897 #[test]
2898 fn infer_trait_assoc_method_generics_4() {
2899     assert_snapshot!(
2900         infer(r#"
2901 trait Trait<T> {
2902     fn make() -> (Self, T);
2903 }
2904 struct S<T>;
2905 impl Trait<i64> for S<u64> {}
2906 impl Trait<i32> for S<u32> {}
2907 fn test() {
2908     let a: (S<u64>, _) = S::make();
2909     let b: (_, i32) = S::make();
2910 }
2911 "#),
2912         @r###"
2913     [131; 203) '{     ...e(); }': ()
2914     [141; 142) 'a': (S<u64>, i64)
2915     [158; 165) 'S::make': fn make<S<u64>, i64>() -> (Self, T)
2916     [158; 167) 'S::make()': (S<u64>, i64)
2917     [177; 178) 'b': (S<u32>, i32)
2918     [191; 198) 'S::make': fn make<S<u32>, i32>() -> (Self, T)
2919     [191; 200) 'S::make()': (S<u32>, i32)
2920     "###
2921     );
2922 }
2923
2924 #[test]
2925 fn infer_trait_assoc_method_generics_5() {
2926     assert_snapshot!(
2927         infer(r#"
2928 trait Trait<T> {
2929     fn make<U>() -> (Self, T, U);
2930 }
2931 struct S<T>;
2932 impl Trait<i64> for S<u64> {}
2933 fn test() {
2934     let a = <S as Trait<i64>>::make::<u8>();
2935     let b: (S<u64>, _, _) = Trait::<i64>::make::<u8>();
2936 }
2937 "#),
2938         @r###"
2939     [107; 211) '{     ...>(); }': ()
2940     [117; 118) 'a': (S<u64>, i64, u8)
2941     [121; 150) '<S as ...::<u8>': fn make<S<u64>, i64, u8>() -> (Self, T, U)
2942     [121; 152) '<S as ...<u8>()': (S<u64>, i64, u8)
2943     [162; 163) 'b': (S<u64>, i64, u8)
2944     [182; 206) 'Trait:...::<u8>': fn make<S<u64>, i64, u8>() -> (Self, T, U)
2945     [182; 208) 'Trait:...<u8>()': (S<u64>, i64, u8)
2946     "###
2947     );
2948 }
2949
2950 #[test]
2951 fn infer_from_bound_1() {
2952     assert_snapshot!(
2953         infer(r#"
2954 trait Trait<T> {}
2955 struct S<T>(T);
2956 impl<U> Trait<U> for S<U> {}
2957 fn foo<T: Trait<u32>>(t: T) {}
2958 fn test() {
2959     let s = S(unknown);
2960     foo(s);
2961 }
2962 "#),
2963         @r###"
2964     [86; 87) 't': T
2965     [92; 94) '{}': ()
2966     [105; 144) '{     ...(s); }': ()
2967     [115; 116) 's': S<u32>
2968     [119; 120) 'S': S<u32>(T) -> S<T>
2969     [119; 129) 'S(unknown)': S<u32>
2970     [121; 128) 'unknown': u32
2971     [135; 138) 'foo': fn foo<S<u32>>(T) -> ()
2972     [135; 141) 'foo(s)': ()
2973     [139; 140) 's': S<u32>
2974     "###
2975     );
2976 }
2977
2978 #[test]
2979 fn infer_from_bound_2() {
2980     assert_snapshot!(
2981         infer(r#"
2982 trait Trait<T> {}
2983 struct S<T>(T);
2984 impl<U> Trait<U> for S<U> {}
2985 fn foo<U, T: Trait<U>>(t: T) -> U {}
2986 fn test() {
2987     let s = S(unknown);
2988     let x: u32 = foo(s);
2989 }
2990 "#),
2991         @r###"
2992     [87; 88) 't': T
2993     [98; 100) '{}': ()
2994     [111; 163) '{     ...(s); }': ()
2995     [121; 122) 's': S<u32>
2996     [125; 126) 'S': S<u32>(T) -> S<T>
2997     [125; 135) 'S(unknown)': S<u32>
2998     [127; 134) 'unknown': u32
2999     [145; 146) 'x': u32
3000     [154; 157) 'foo': fn foo<u32, S<u32>>(T) -> U
3001     [154; 160) 'foo(s)': u32
3002     [158; 159) 's': S<u32>
3003     "###
3004     );
3005 }
3006
3007 #[test]
3008 fn infer_call_trait_method_on_generic_param_1() {
3009     assert_snapshot!(
3010         infer(r#"
3011 trait Trait {
3012     fn method(&self) -> u32;
3013 }
3014 fn test<T: Trait>(t: T) {
3015     t.method();
3016 }
3017 "#),
3018         @r###"
3019     [30; 34) 'self': &Self
3020     [64; 65) 't': T
3021     [70; 89) '{     ...d(); }': ()
3022     [76; 77) 't': T
3023     [76; 86) 't.method()': u32
3024     "###
3025     );
3026 }
3027
3028 #[test]
3029 fn infer_call_trait_method_on_generic_param_2() {
3030     assert_snapshot!(
3031         infer(r#"
3032 trait Trait<T> {
3033     fn method(&self) -> T;
3034 }
3035 fn test<U, T: Trait<U>>(t: T) {
3036     t.method();
3037 }
3038 "#),
3039         @r###"
3040     [33; 37) 'self': &Self
3041     [71; 72) 't': T
3042     [77; 96) '{     ...d(); }': ()
3043     [83; 84) 't': T
3044     [83; 93) 't.method()': [missing name]
3045     "###
3046     );
3047 }
3048
3049 #[test]
3050 fn infer_with_multiple_trait_impls() {
3051     assert_snapshot!(
3052         infer(r#"
3053 trait Into<T> {
3054     fn into(self) -> T;
3055 }
3056 struct S;
3057 impl Into<u32> for S {}
3058 impl Into<u64> for S {}
3059 fn test() {
3060     let x: u32 = S.into();
3061     let y: u64 = S.into();
3062     let z = Into::<u64>::into(S);
3063 }
3064 "#),
3065         @r###"
3066     [29; 33) 'self': Self
3067     [111; 202) '{     ...(S); }': ()
3068     [121; 122) 'x': u32
3069     [130; 131) 'S': S
3070     [130; 138) 'S.into()': u32
3071     [148; 149) 'y': u64
3072     [157; 158) 'S': S
3073     [157; 165) 'S.into()': u64
3074     [175; 176) 'z': u64
3075     [179; 196) 'Into::...::into': fn into<S, u64>(Self) -> T
3076     [179; 199) 'Into::...nto(S)': u64
3077     [197; 198) 'S': S
3078     "###
3079     );
3080 }
3081
3082 #[test]
3083 fn infer_project_associated_type() {
3084     // y, z, a don't yet work because of https://github.com/rust-lang/chalk/issues/234
3085     assert_snapshot!(
3086         infer(r#"
3087 trait Iterable {
3088    type Item;
3089 }
3090 struct S;
3091 impl Iterable for S { type Item = u32; }
3092 fn test<T: Iterable>() {
3093     let x: <S as Iterable>::Item = 1;
3094     let y: <T as Iterable>::Item = no_matter;
3095     let z: T::Item = no_matter;
3096     let a: <T>::Item = no_matter;
3097 }
3098 "#),
3099         @r###"
3100     [108; 261) '{     ...ter; }': ()
3101     [118; 119) 'x': u32
3102     [145; 146) '1': u32
3103     [156; 157) 'y': {unknown}
3104     [183; 192) 'no_matter': {unknown}
3105     [202; 203) 'z': {unknown}
3106     [215; 224) 'no_matter': {unknown}
3107     [234; 235) 'a': {unknown}
3108     [249; 258) 'no_matter': {unknown}
3109     "###
3110     );
3111 }
3112
3113 #[test]
3114 fn infer_return_associated_type() {
3115     assert_snapshot!(
3116         infer(r#"
3117 trait Iterable {
3118    type Item;
3119 }
3120 struct S;
3121 impl Iterable for S { type Item = u32; }
3122 fn foo1<T: Iterable>(t: T) -> T::Item {}
3123 fn foo2<T: Iterable>(t: T) -> <T as Iterable>::Item {}
3124 fn foo3<T: Iterable>(t: T) -> <T>::Item {}
3125 fn test() {
3126     let x = foo1(S);
3127     let y = foo2(S);
3128     let z = foo3(S);
3129 }
3130 "#),
3131         @r###"
3132     [106; 107) 't': T
3133     [123; 125) '{}': ()
3134     [147; 148) 't': T
3135     [178; 180) '{}': ()
3136     [202; 203) 't': T
3137     [221; 223) '{}': ()
3138     [234; 300) '{     ...(S); }': ()
3139     [244; 245) 'x': u32
3140     [248; 252) 'foo1': fn foo1<S>(T) -> <T as Iterable>::Item
3141     [248; 255) 'foo1(S)': u32
3142     [253; 254) 'S': S
3143     [265; 266) 'y': u32
3144     [269; 273) 'foo2': fn foo2<S>(T) -> <T as Iterable>::Item
3145     [269; 276) 'foo2(S)': u32
3146     [274; 275) 'S': S
3147     [286; 287) 'z': u32
3148     [290; 294) 'foo3': fn foo3<S>(T) -> <T as Iterable>::Item
3149     [290; 297) 'foo3(S)': u32
3150     [295; 296) 'S': S
3151     "###
3152     );
3153 }
3154
3155 #[test]
3156 fn infer_associated_type_bound() {
3157     assert_snapshot!(
3158         infer(r#"
3159 trait Iterable {
3160    type Item;
3161 }
3162 fn test<T: Iterable<Item=u32>>() {
3163     let y: T::Item = unknown;
3164 }
3165 "#),
3166         @r###"
3167     [67; 100) '{     ...own; }': ()
3168     [77; 78) 'y': {unknown}
3169     [90; 97) 'unknown': {unknown}
3170     "###
3171     );
3172 }
3173
3174 #[test]
3175 fn infer_const_body() {
3176     assert_snapshot!(
3177         infer(r#"
3178 const A: u32 = 1 + 1;
3179 static B: u64 = { let x = 1; x };
3180 "#),
3181         @r###"
3182     [16; 17) '1': u32
3183     [16; 21) '1 + 1': u32
3184     [20; 21) '1': u32
3185     [39; 55) '{ let ...1; x }': u64
3186     [45; 46) 'x': u64
3187     [49; 50) '1': u64
3188     [52; 53) 'x': u64
3189     "###
3190     );
3191 }
3192
3193 #[test]
3194 fn tuple_struct_fields() {
3195     assert_snapshot!(
3196         infer(r#"
3197 struct S(i32, u64);
3198 fn test() -> u64 {
3199     let a = S(4, 6);
3200     let b = a.0;
3201     a.1
3202 }
3203 "#),
3204         @r###"
3205     [38; 87) '{     ... a.1 }': u64
3206     [48; 49) 'a': S
3207     [52; 53) 'S': S(i32, u64) -> S
3208     [52; 59) 'S(4, 6)': S
3209     [54; 55) '4': i32
3210     [57; 58) '6': u64
3211     [69; 70) 'b': i32
3212     [73; 74) 'a': S
3213     [73; 76) 'a.0': i32
3214     [82; 83) 'a': S
3215     [82; 85) 'a.1': u64
3216     "###
3217     );
3218 }
3219
3220 #[test]
3221 fn tuple_struct_with_fn() {
3222     assert_snapshot!(
3223         infer(r#"
3224 struct S(fn(u32) -> u64);
3225 fn test() -> u64 {
3226     let a = S(|i| 2*i);
3227     let b = a.0(4);
3228     a.0(2)
3229 }
3230 "#),
3231         @r###"
3232     [44; 102) '{     ...0(2) }': u64
3233     [54; 55) 'a': S
3234     [58; 59) 'S': S(fn(u32) -> u64) -> S
3235     [58; 68) 'S(|i| 2*i)': S
3236     [60; 67) '|i| 2*i': |i32| -> i32
3237     [61; 62) 'i': i32
3238     [64; 65) '2': i32
3239     [64; 67) '2*i': i32
3240     [66; 67) 'i': i32
3241     [78; 79) 'b': u64
3242     [82; 83) 'a': S
3243     [82; 85) 'a.0': fn(u32) -> u64
3244     [82; 88) 'a.0(4)': u64
3245     [86; 87) '4': u32
3246     [94; 95) 'a': S
3247     [94; 97) 'a.0': fn(u32) -> u64
3248     [94; 100) 'a.0(2)': u64
3249     [98; 99) '2': u32
3250     "###
3251     );
3252 }
3253
3254 #[test]
3255 fn indexing_arrays() {
3256     assert_snapshot!(
3257         infer("fn main() { &mut [9][2]; }"),
3258         @r###"
3259     [10; 26) '{ &mut...[2]; }': ()
3260     [12; 23) '&mut [9][2]': &mut {unknown}
3261     [17; 20) '[9]': [i32;_]
3262     [17; 23) '[9][2]': {unknown}
3263     [18; 19) '9': i32
3264     [21; 22) '2': i32
3265     "###
3266     )
3267 }
3268
3269 #[test]
3270 fn infer_macros_expanded() {
3271     assert_snapshot!(
3272         infer(r#"
3273 struct Foo(Vec<i32>);
3274
3275 macro_rules! foo {
3276     ($($item:expr),*) => {
3277             {
3278                 Foo(vec![$($item,)*])
3279             }
3280     };
3281 }
3282
3283 fn main() {
3284     let x = foo!(1,2);
3285 }
3286 "#),
3287         @r###"
3288     ![0; 17) '{Foo(v...,2,])}': Foo
3289     ![1; 4) 'Foo': Foo({unknown}) -> Foo
3290     ![1; 16) 'Foo(vec![1,2,])': Foo
3291     ![5; 15) 'vec![1,2,]': {unknown}
3292     [156; 182) '{     ...,2); }': ()
3293     [166; 167) 'x': Foo
3294     "###
3295     );
3296 }
3297
3298 #[test]
3299 fn infer_legacy_textual_scoped_macros_expanded() {
3300     assert_snapshot!(
3301         infer(r#"
3302 struct Foo(Vec<i32>);
3303
3304 #[macro_use]
3305 mod m {
3306     macro_rules! foo {
3307         ($($item:expr),*) => {
3308             {
3309                 Foo(vec![$($item,)*])
3310             }
3311         };
3312     }
3313 }
3314
3315 fn main() {
3316     let x = foo!(1,2);
3317     let y = crate::foo!(1,2);
3318 }
3319 "#),
3320         @r###"
3321     ![0; 17) '{Foo(v...,2,])}': Foo
3322     ![1; 4) 'Foo': Foo({unknown}) -> Foo
3323     ![1; 16) 'Foo(vec![1,2,])': Foo
3324     ![5; 15) 'vec![1,2,]': {unknown}
3325     [195; 251) '{     ...,2); }': ()
3326     [205; 206) 'x': Foo
3327     [228; 229) 'y': {unknown}
3328     [232; 248) 'crate:...!(1,2)': {unknown}
3329     "###
3330     );
3331 }
3332
3333 #[test]
3334 fn infer_path_qualified_macros_expanded() {
3335     assert_snapshot!(
3336         infer(r#"
3337 #[macro_export]
3338 macro_rules! foo {
3339     () => { 42i32 }
3340 }
3341
3342 mod m {
3343     pub use super::foo as bar;
3344 }
3345
3346 fn main() {
3347     let x = crate::foo!();
3348     let y = m::bar!();
3349 }
3350 "#),
3351         @r###"
3352     ![0; 5) '42i32': i32
3353     ![0; 5) '42i32': i32
3354     [111; 164) '{     ...!(); }': ()
3355     [121; 122) 'x': i32
3356     [148; 149) 'y': i32
3357     "###
3358     );
3359 }
3360
3361 #[test]
3362 fn infer_type_value_macro_having_same_name() {
3363     assert_snapshot!(
3364         infer(r#"
3365 #[macro_export]
3366 macro_rules! foo {
3367     () => {
3368         mod foo {
3369             pub use super::foo;
3370         }
3371     };
3372     ($x:tt) => {
3373         $x
3374     };
3375 }
3376
3377 foo!();
3378
3379 fn foo() {
3380     let foo = foo::foo!(42i32);
3381 }
3382 "#),
3383         @r###"
3384     ![0; 5) '42i32': i32
3385     [171; 206) '{     ...32); }': ()
3386     [181; 184) 'foo': i32
3387     "###
3388     );
3389 }
3390
3391 #[test]
3392 fn processes_impls_generated_by_macros() {
3393     let t = type_at(
3394         r#"
3395 //- /main.rs
3396 macro_rules! m {
3397     ($ident:ident) => (impl Trait for $ident {})
3398 }
3399 trait Trait { fn foo(self) -> u128 {} }
3400 struct S;
3401 m!(S);
3402 fn test() { S.foo()<|>; }
3403 "#,
3404     );
3405     assert_eq!(t, "u128");
3406 }
3407
3408 #[test]
3409 fn infer_macro_with_dollar_crate_is_correct_in_expr() {
3410     let (db, pos) = TestDB::with_position(
3411         r#"
3412 //- /main.rs crate:main deps:foo
3413 fn test() {
3414     let x = (foo::foo!(1), foo::foo!(2));
3415     x<|>;
3416 }
3417
3418 //- /lib.rs crate:foo
3419 #[macro_export]
3420 macro_rules! foo {
3421     (1) => { $crate::bar!() };
3422     (2) => { 1 + $crate::baz() };
3423 }
3424
3425 #[macro_export]
3426 macro_rules! bar {
3427     () => { 42 }
3428 }
3429
3430 pub fn baz() -> usize { 31usize }
3431 "#,
3432     );
3433     assert_eq!("(i32, usize)", type_at_pos(&db, pos));
3434 }
3435
3436 #[ignore]
3437 #[test]
3438 fn method_resolution_trait_before_autoref() {
3439     let t = type_at(
3440         r#"
3441 //- /main.rs
3442 trait Trait { fn foo(self) -> u128; }
3443 struct S;
3444 impl S { fn foo(&self) -> i8 { 0 } }
3445 impl Trait for S { fn foo(self) -> u128 { 0 } }
3446 fn test() { S.foo()<|>; }
3447 "#,
3448     );
3449     assert_eq!(t, "u128");
3450 }
3451
3452 #[ignore]
3453 #[test]
3454 fn method_resolution_by_value_before_autoref() {
3455     let t = type_at(
3456         r#"
3457 //- /main.rs
3458 trait Clone { fn clone(&self) -> Self; }
3459 struct S;
3460 impl Clone for S {}
3461 impl Clone for &S {}
3462 fn test() { (S.clone(), (&S).clone(), (&&S).clone())<|>; }
3463 "#,
3464     );
3465     assert_eq!(t, "(S, S, &S)");
3466 }
3467
3468 #[test]
3469 fn method_resolution_trait_before_autoderef() {
3470     let t = type_at(
3471         r#"
3472 //- /main.rs
3473 trait Trait { fn foo(self) -> u128; }
3474 struct S;
3475 impl S { fn foo(self) -> i8 { 0 } }
3476 impl Trait for &S { fn foo(self) -> u128 { 0 } }
3477 fn test() { (&S).foo()<|>; }
3478 "#,
3479     );
3480     assert_eq!(t, "u128");
3481 }
3482
3483 #[test]
3484 fn method_resolution_impl_before_trait() {
3485     let t = type_at(
3486         r#"
3487 //- /main.rs
3488 trait Trait { fn foo(self) -> u128; }
3489 struct S;
3490 impl S { fn foo(self) -> i8 { 0 } }
3491 impl Trait for S { fn foo(self) -> u128 { 0 } }
3492 fn test() { S.foo()<|>; }
3493 "#,
3494     );
3495     assert_eq!(t, "i8");
3496 }
3497
3498 #[test]
3499 fn method_resolution_trait_autoderef() {
3500     let t = type_at(
3501         r#"
3502 //- /main.rs
3503 trait Trait { fn foo(self) -> u128; }
3504 struct S;
3505 impl Trait for S { fn foo(self) -> u128 { 0 } }
3506 fn test() { (&S).foo()<|>; }
3507 "#,
3508     );
3509     assert_eq!(t, "u128");
3510 }
3511
3512 #[test]
3513 fn method_resolution_trait_from_prelude() {
3514     let (db, pos) = TestDB::with_position(
3515         r#"
3516 //- /main.rs crate:main deps:other_crate
3517 struct S;
3518 impl Clone for S {}
3519
3520 fn test() {
3521     S.clone()<|>;
3522 }
3523
3524 //- /lib.rs crate:other_crate
3525 #[prelude_import] use foo::*;
3526
3527 mod foo {
3528     trait Clone {
3529         fn clone(&self) -> Self;
3530     }
3531 }
3532 "#,
3533     );
3534     assert_eq!("S", type_at_pos(&db, pos));
3535 }
3536
3537 #[test]
3538 fn method_resolution_where_clause_for_unknown_trait() {
3539     // The blanket impl shouldn't apply because we can't even resolve UnknownTrait
3540     let t = type_at(
3541         r#"
3542 //- /main.rs
3543 trait Trait { fn foo(self) -> u128; }
3544 struct S;
3545 impl<T> Trait for T where T: UnknownTrait {}
3546 fn test() { (&S).foo()<|>; }
3547 "#,
3548     );
3549     assert_eq!(t, "{unknown}");
3550 }
3551
3552 #[test]
3553 fn method_resolution_where_clause_not_met() {
3554     // The blanket impl shouldn't apply because we can't prove S: Clone
3555     let t = type_at(
3556         r#"
3557 //- /main.rs
3558 trait Clone {}
3559 trait Trait { fn foo(self) -> u128; }
3560 struct S;
3561 impl<T> Trait for T where T: Clone {}
3562 fn test() { (&S).foo()<|>; }
3563 "#,
3564     );
3565     // This is also to make sure that we don't resolve to the foo method just
3566     // because that's the only method named foo we can find, which would make
3567     // the below tests not work
3568     assert_eq!(t, "{unknown}");
3569 }
3570
3571 #[test]
3572 fn method_resolution_where_clause_inline_not_met() {
3573     // The blanket impl shouldn't apply because we can't prove S: Clone
3574     let t = type_at(
3575         r#"
3576 //- /main.rs
3577 trait Clone {}
3578 trait Trait { fn foo(self) -> u128; }
3579 struct S;
3580 impl<T: Clone> Trait for T {}
3581 fn test() { (&S).foo()<|>; }
3582 "#,
3583     );
3584     assert_eq!(t, "{unknown}");
3585 }
3586
3587 #[test]
3588 fn method_resolution_where_clause_1() {
3589     let t = type_at(
3590         r#"
3591 //- /main.rs
3592 trait Clone {}
3593 trait Trait { fn foo(self) -> u128; }
3594 struct S;
3595 impl Clone for S {}
3596 impl<T> Trait for T where T: Clone {}
3597 fn test() { S.foo()<|>; }
3598 "#,
3599     );
3600     assert_eq!(t, "u128");
3601 }
3602
3603 #[test]
3604 fn method_resolution_where_clause_2() {
3605     let t = type_at(
3606         r#"
3607 //- /main.rs
3608 trait Into<T> { fn into(self) -> T; }
3609 trait From<T> { fn from(other: T) -> Self; }
3610 struct S1;
3611 struct S2;
3612 impl From<S2> for S1 {}
3613 impl<T, U> Into<U> for T where U: From<T> {}
3614 fn test() { S2.into()<|>; }
3615 "#,
3616     );
3617     assert_eq!(t, "{unknown}");
3618 }
3619
3620 #[test]
3621 fn method_resolution_where_clause_inline() {
3622     let t = type_at(
3623         r#"
3624 //- /main.rs
3625 trait Into<T> { fn into(self) -> T; }
3626 trait From<T> { fn from(other: T) -> Self; }
3627 struct S1;
3628 struct S2;
3629 impl From<S2> for S1 {}
3630 impl<T, U: From<T>> Into<U> for T {}
3631 fn test() { S2.into()<|>; }
3632 "#,
3633     );
3634     assert_eq!(t, "{unknown}");
3635 }
3636
3637 #[test]
3638 fn method_resolution_encountering_fn_type() {
3639     type_at(
3640         r#"
3641 //- /main.rs
3642 fn foo() {}
3643 trait FnOnce { fn call(self); }
3644 fn test() { foo.call()<|>; }
3645 "#,
3646     );
3647 }
3648
3649 #[test]
3650 fn method_resolution_slow() {
3651     // this can get quite slow if we set the solver size limit too high
3652     let t = type_at(
3653         r#"
3654 //- /main.rs
3655 trait SendX {}
3656
3657 struct S1; impl SendX for S1 {}
3658 struct S2; impl SendX for S2 {}
3659 struct U1;
3660
3661 trait Trait { fn method(self); }
3662
3663 struct X1<A, B> {}
3664 impl<A, B> SendX for X1<A, B> where A: SendX, B: SendX {}
3665
3666 struct S<B, C> {}
3667
3668 trait FnX {}
3669
3670 impl<B, C> Trait for S<B, C> where C: FnX, B: SendX {}
3671
3672 fn test() { (S {}).method()<|>; }
3673 "#,
3674     );
3675     assert_eq!(t, "()");
3676 }
3677
3678 #[test]
3679 fn shadowing_primitive() {
3680     let t = type_at(
3681         r#"
3682 //- /main.rs
3683 struct i32;
3684 struct Foo;
3685
3686 impl i32 { fn foo(&self) -> Foo { Foo } }
3687
3688 fn main() {
3689     let x: i32 = i32;
3690     x.foo()<|>;
3691 }"#,
3692     );
3693     assert_eq!(t, "Foo");
3694 }
3695
3696 #[test]
3697 fn not_shadowing_primitive_by_module() {
3698     let t = type_at(
3699         r#"
3700 //- /str.rs
3701 fn foo() {}
3702
3703 //- /main.rs
3704 mod str;
3705 fn foo() -> &'static str { "" }
3706
3707 fn main() {
3708     foo()<|>;
3709 }"#,
3710     );
3711     assert_eq!(t, "&str");
3712 }
3713
3714 #[test]
3715 fn not_shadowing_module_by_primitive() {
3716     let t = type_at(
3717         r#"
3718 //- /str.rs
3719 fn foo() -> u32 {0}
3720
3721 //- /main.rs
3722 mod str;
3723 fn foo() -> &'static str { "" }
3724
3725 fn main() {
3726     str::foo()<|>;
3727 }"#,
3728     );
3729     assert_eq!(t, "u32");
3730 }
3731
3732 #[test]
3733 fn deref_trait() {
3734     let t = type_at(
3735         r#"
3736 //- /main.rs
3737 #[lang = "deref"]
3738 trait Deref {
3739     type Target;
3740     fn deref(&self) -> &Self::Target;
3741 }
3742
3743 struct Arc<T>;
3744 impl<T> Deref for Arc<T> {
3745     type Target = T;
3746 }
3747
3748 struct S;
3749 impl S {
3750     fn foo(&self) -> u128 {}
3751 }
3752
3753 fn test(s: Arc<S>) {
3754     (*s, s.foo())<|>;
3755 }
3756 "#,
3757     );
3758     assert_eq!(t, "(S, u128)");
3759 }
3760
3761 #[test]
3762 fn deref_trait_with_inference_var() {
3763     let t = type_at(
3764         r#"
3765 //- /main.rs
3766 #[lang = "deref"]
3767 trait Deref {
3768     type Target;
3769     fn deref(&self) -> &Self::Target;
3770 }
3771
3772 struct Arc<T>;
3773 fn new_arc<T>() -> Arc<T> {}
3774 impl<T> Deref for Arc<T> {
3775     type Target = T;
3776 }
3777
3778 struct S;
3779 fn foo(a: Arc<S>) {}
3780
3781 fn test() {
3782     let a = new_arc();
3783     let b = (*a)<|>;
3784     foo(a);
3785 }
3786 "#,
3787     );
3788     assert_eq!(t, "S");
3789 }
3790
3791 #[test]
3792 fn deref_trait_infinite_recursion() {
3793     let t = type_at(
3794         r#"
3795 //- /main.rs
3796 #[lang = "deref"]
3797 trait Deref {
3798     type Target;
3799     fn deref(&self) -> &Self::Target;
3800 }
3801
3802 struct S;
3803
3804 impl Deref for S {
3805     type Target = S;
3806 }
3807
3808 fn test(s: S) {
3809     s.foo()<|>;
3810 }
3811 "#,
3812     );
3813     assert_eq!(t, "{unknown}");
3814 }
3815
3816 #[test]
3817 fn deref_trait_with_question_mark_size() {
3818     let t = type_at(
3819         r#"
3820 //- /main.rs
3821 #[lang = "deref"]
3822 trait Deref {
3823     type Target;
3824     fn deref(&self) -> &Self::Target;
3825 }
3826
3827 struct Arc<T>;
3828 impl<T> Deref for Arc<T> {
3829     type Target = T;
3830 }
3831
3832 struct S;
3833 impl S {
3834     fn foo(&self) -> u128 {}
3835 }
3836
3837 fn test(s: Arc<S>) {
3838     (*s, s.foo())<|>;
3839 }
3840 "#,
3841     );
3842     assert_eq!(t, "(S, u128)");
3843 }
3844
3845 #[test]
3846 fn obligation_from_function_clause() {
3847     let t = type_at(
3848         r#"
3849 //- /main.rs
3850 struct S;
3851
3852 trait Trait<T> {}
3853 impl Trait<u32> for S {}
3854
3855 fn foo<T: Trait<U>, U>(t: T) -> U {}
3856
3857 fn test(s: S) {
3858     foo(s)<|>;
3859 }
3860 "#,
3861     );
3862     assert_eq!(t, "u32");
3863 }
3864
3865 #[test]
3866 fn obligation_from_method_clause() {
3867     let t = type_at(
3868         r#"
3869 //- /main.rs
3870 struct S;
3871
3872 trait Trait<T> {}
3873 impl Trait<isize> for S {}
3874
3875 struct O;
3876 impl O {
3877     fn foo<T: Trait<U>, U>(&self, t: T) -> U {}
3878 }
3879
3880 fn test() {
3881     O.foo(S)<|>;
3882 }
3883 "#,
3884     );
3885     assert_eq!(t, "isize");
3886 }
3887
3888 #[test]
3889 fn obligation_from_self_method_clause() {
3890     let t = type_at(
3891         r#"
3892 //- /main.rs
3893 struct S;
3894
3895 trait Trait<T> {}
3896 impl Trait<i64> for S {}
3897
3898 impl S {
3899     fn foo<U>(&self) -> U where Self: Trait<U> {}
3900 }
3901
3902 fn test() {
3903     S.foo()<|>;
3904 }
3905 "#,
3906     );
3907     assert_eq!(t, "i64");
3908 }
3909
3910 #[test]
3911 fn obligation_from_impl_clause() {
3912     let t = type_at(
3913         r#"
3914 //- /main.rs
3915 struct S;
3916
3917 trait Trait<T> {}
3918 impl Trait<&str> for S {}
3919
3920 struct O<T>;
3921 impl<U, T: Trait<U>> O<T> {
3922     fn foo(&self) -> U {}
3923 }
3924
3925 fn test(o: O<S>) {
3926     o.foo()<|>;
3927 }
3928 "#,
3929     );
3930     assert_eq!(t, "&str");
3931 }
3932
3933 #[test]
3934 fn generic_param_env_1() {
3935     let t = type_at(
3936         r#"
3937 //- /main.rs
3938 trait Clone {}
3939 trait Trait { fn foo(self) -> u128; }
3940 struct S;
3941 impl Clone for S {}
3942 impl<T> Trait for T where T: Clone {}
3943 fn test<T: Clone>(t: T) { t.foo()<|>; }
3944 "#,
3945     );
3946     assert_eq!(t, "u128");
3947 }
3948
3949 #[test]
3950 fn generic_param_env_1_not_met() {
3951     let t = type_at(
3952         r#"
3953 //- /main.rs
3954 trait Clone {}
3955 trait Trait { fn foo(self) -> u128; }
3956 struct S;
3957 impl Clone for S {}
3958 impl<T> Trait for T where T: Clone {}
3959 fn test<T>(t: T) { t.foo()<|>; }
3960 "#,
3961     );
3962     assert_eq!(t, "{unknown}");
3963 }
3964
3965 #[test]
3966 fn generic_param_env_2() {
3967     let t = type_at(
3968         r#"
3969 //- /main.rs
3970 trait Trait { fn foo(self) -> u128; }
3971 struct S;
3972 impl Trait for S {}
3973 fn test<T: Trait>(t: T) { t.foo()<|>; }
3974 "#,
3975     );
3976     assert_eq!(t, "u128");
3977 }
3978
3979 #[test]
3980 fn generic_param_env_2_not_met() {
3981     let t = type_at(
3982         r#"
3983 //- /main.rs
3984 trait Trait { fn foo(self) -> u128; }
3985 struct S;
3986 impl Trait for S {}
3987 fn test<T>(t: T) { t.foo()<|>; }
3988 "#,
3989     );
3990     assert_eq!(t, "{unknown}");
3991 }
3992
3993 #[test]
3994 fn generic_param_env_deref() {
3995     let t = type_at(
3996         r#"
3997 //- /main.rs
3998 #[lang = "deref"]
3999 trait Deref {
4000     type Target;
4001 }
4002 trait Trait {}
4003 impl<T> Deref for T where T: Trait {
4004     type Target = i128;
4005 }
4006 fn test<T: Trait>(t: T) { (*t)<|>; }
4007 "#,
4008     );
4009     assert_eq!(t, "i128");
4010 }
4011
4012 #[test]
4013 fn associated_type_placeholder() {
4014     let t = type_at(
4015         r#"
4016 //- /main.rs
4017 pub trait ApplyL {
4018     type Out;
4019 }
4020
4021 pub struct RefMutL<T>;
4022
4023 impl<T> ApplyL for RefMutL<T> {
4024     type Out = <T as ApplyL>::Out;
4025 }
4026
4027 fn test<T: ApplyL>() {
4028     let y: <RefMutL<T> as ApplyL>::Out = no_matter;
4029     y<|>;
4030 }
4031 "#,
4032     );
4033     // 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].
4034     // FIXME: fix type parameter names going missing when going through Chalk
4035     assert_eq!(t, "ApplyL::Out<[missing name]>");
4036 }
4037
4038 #[test]
4039 fn associated_type_placeholder_2() {
4040     let t = type_at(
4041         r#"
4042 //- /main.rs
4043 pub trait ApplyL {
4044     type Out;
4045 }
4046 fn foo<T: ApplyL>(t: T) -> <T as ApplyL>::Out;
4047
4048 fn test<T: ApplyL>(t: T) {
4049     let y = foo(t);
4050     y<|>;
4051 }
4052 "#,
4053     );
4054     // FIXME here Chalk doesn't normalize the type to a placeholder. I think we
4055     // need to add a rule like Normalize(<T as ApplyL>::Out -> ApplyL::Out<T>)
4056     // to the trait env ourselves here; probably Chalk can't do this by itself.
4057     // assert_eq!(t, "ApplyL::Out<[missing name]>");
4058     assert_eq!(t, "{unknown}");
4059 }
4060
4061 #[test]
4062 fn impl_trait() {
4063     assert_snapshot!(
4064         infer(r#"
4065 trait Trait<T> {
4066     fn foo(&self) -> T;
4067     fn foo2(&self) -> i64;
4068 }
4069 fn bar() -> impl Trait<u64> {}
4070
4071 fn test(x: impl Trait<u64>, y: &impl Trait<u64>) {
4072     x;
4073     y;
4074     let z = bar();
4075     x.foo();
4076     y.foo();
4077     z.foo();
4078     x.foo2();
4079     y.foo2();
4080     z.foo2();
4081 }
4082 "#),
4083         @r###"
4084     [30; 34) 'self': &Self
4085     [55; 59) 'self': &Self
4086     [99; 101) '{}': ()
4087     [111; 112) 'x': impl Trait<u64>
4088     [131; 132) 'y': &impl Trait<u64>
4089     [152; 269) '{     ...2(); }': ()
4090     [158; 159) 'x': impl Trait<u64>
4091     [165; 166) 'y': &impl Trait<u64>
4092     [176; 177) 'z': impl Trait<u64>
4093     [180; 183) 'bar': fn bar() -> impl Trait<u64>
4094     [180; 185) 'bar()': impl Trait<u64>
4095     [191; 192) 'x': impl Trait<u64>
4096     [191; 198) 'x.foo()': u64
4097     [204; 205) 'y': &impl Trait<u64>
4098     [204; 211) 'y.foo()': u64
4099     [217; 218) 'z': impl Trait<u64>
4100     [217; 224) 'z.foo()': u64
4101     [230; 231) 'x': impl Trait<u64>
4102     [230; 238) 'x.foo2()': i64
4103     [244; 245) 'y': &impl Trait<u64>
4104     [244; 252) 'y.foo2()': i64
4105     [258; 259) 'z': impl Trait<u64>
4106     [258; 266) 'z.foo2()': i64
4107     "###
4108     );
4109 }
4110
4111 #[test]
4112 fn dyn_trait() {
4113     assert_snapshot!(
4114         infer(r#"
4115 trait Trait<T> {
4116     fn foo(&self) -> T;
4117     fn foo2(&self) -> i64;
4118 }
4119 fn bar() -> dyn Trait<u64> {}
4120
4121 fn test(x: dyn Trait<u64>, y: &dyn Trait<u64>) {
4122     x;
4123     y;
4124     let z = bar();
4125     x.foo();
4126     y.foo();
4127     z.foo();
4128     x.foo2();
4129     y.foo2();
4130     z.foo2();
4131 }
4132 "#),
4133         @r###"
4134     [30; 34) 'self': &Self
4135     [55; 59) 'self': &Self
4136     [98; 100) '{}': ()
4137     [110; 111) 'x': dyn Trait<u64>
4138     [129; 130) 'y': &dyn Trait<u64>
4139     [149; 266) '{     ...2(); }': ()
4140     [155; 156) 'x': dyn Trait<u64>
4141     [162; 163) 'y': &dyn Trait<u64>
4142     [173; 174) 'z': dyn Trait<u64>
4143     [177; 180) 'bar': fn bar() -> dyn Trait<u64>
4144     [177; 182) 'bar()': dyn Trait<u64>
4145     [188; 189) 'x': dyn Trait<u64>
4146     [188; 195) 'x.foo()': u64
4147     [201; 202) 'y': &dyn Trait<u64>
4148     [201; 208) 'y.foo()': u64
4149     [214; 215) 'z': dyn Trait<u64>
4150     [214; 221) 'z.foo()': u64
4151     [227; 228) 'x': dyn Trait<u64>
4152     [227; 235) 'x.foo2()': i64
4153     [241; 242) 'y': &dyn Trait<u64>
4154     [241; 249) 'y.foo2()': i64
4155     [255; 256) 'z': dyn Trait<u64>
4156     [255; 263) 'z.foo2()': i64
4157     "###
4158     );
4159 }
4160
4161 #[test]
4162 fn dyn_trait_bare() {
4163     assert_snapshot!(
4164         infer(r#"
4165 trait Trait {
4166     fn foo(&self) -> u64;
4167 }
4168 fn bar() -> Trait {}
4169
4170 fn test(x: Trait, y: &Trait) -> u64 {
4171     x;
4172     y;
4173     let z = bar();
4174     x.foo();
4175     y.foo();
4176     z.foo();
4177 }
4178 "#),
4179         @r###"
4180     [27; 31) 'self': &Self
4181     [61; 63) '{}': ()
4182     [73; 74) 'x': dyn Trait
4183     [83; 84) 'y': &dyn Trait
4184     [101; 176) '{     ...o(); }': ()
4185     [107; 108) 'x': dyn Trait
4186     [114; 115) 'y': &dyn Trait
4187     [125; 126) 'z': dyn Trait
4188     [129; 132) 'bar': fn bar() -> dyn Trait
4189     [129; 134) 'bar()': dyn Trait
4190     [140; 141) 'x': dyn Trait
4191     [140; 147) 'x.foo()': u64
4192     [153; 154) 'y': &dyn Trait
4193     [153; 160) 'y.foo()': u64
4194     [166; 167) 'z': dyn Trait
4195     [166; 173) 'z.foo()': u64
4196     "###
4197     );
4198 }
4199
4200 #[test]
4201 fn weird_bounds() {
4202     assert_snapshot!(
4203         infer(r#"
4204 trait Trait {}
4205 fn test() {
4206     let a: impl Trait + 'lifetime = foo;
4207     let b: impl 'lifetime = foo;
4208     let b: impl (Trait) = foo;
4209     let b: impl ('lifetime) = foo;
4210     let d: impl ?Sized = foo;
4211     let e: impl Trait + ?Sized = foo;
4212 }
4213 "#),
4214         @r###"
4215     [26; 237) '{     ...foo; }': ()
4216     [36; 37) 'a': impl Trait + {error}
4217     [64; 67) 'foo': impl Trait + {error}
4218     [77; 78) 'b': impl {error}
4219     [97; 100) 'foo': impl {error}
4220     [110; 111) 'b': impl Trait
4221     [128; 131) 'foo': impl Trait
4222     [141; 142) 'b': impl {error}
4223     [163; 166) 'foo': impl {error}
4224     [176; 177) 'd': impl {error}
4225     [193; 196) 'foo': impl {error}
4226     [206; 207) 'e': impl Trait + {error}
4227     [231; 234) 'foo': impl Trait + {error}
4228     "###
4229     );
4230 }
4231
4232 #[test]
4233 fn assoc_type_bindings() {
4234     assert_snapshot!(
4235         infer(r#"
4236 trait Trait {
4237     type Type;
4238 }
4239
4240 fn get<T: Trait>(t: T) -> <T as Trait>::Type {}
4241 fn get2<U, T: Trait<Type = U>>(t: T) -> U {}
4242 fn set<T: Trait<Type = u64>>(t: T) -> T {t}
4243
4244 struct S<T>;
4245 impl<T> Trait for S<T> { type Type = T; }
4246
4247 fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
4248     get(x);
4249     get2(x);
4250     get(y);
4251     get2(y);
4252     get(set(S));
4253     get2(set(S));
4254     get2(S::<str>);
4255 }
4256 "#),
4257         @r###"
4258     [50; 51) 't': T
4259     [78; 80) '{}': ()
4260     [112; 113) 't': T
4261     [123; 125) '{}': ()
4262     [155; 156) 't': T
4263     [166; 169) '{t}': T
4264     [167; 168) 't': T
4265     [257; 258) 'x': T
4266     [263; 264) 'y': impl Trait<Type = i64>
4267     [290; 398) '{     ...r>); }': ()
4268     [296; 299) 'get': fn get<T>(T) -> <T as Trait>::Type
4269     [296; 302) 'get(x)': {unknown}
4270     [300; 301) 'x': T
4271     [308; 312) 'get2': fn get2<{unknown}, T>(T) -> U
4272     [308; 315) 'get2(x)': {unknown}
4273     [313; 314) 'x': T
4274     [321; 324) 'get': fn get<impl Trait<Type = i64>>(T) -> <T as Trait>::Type
4275     [321; 327) 'get(y)': {unknown}
4276     [325; 326) 'y': impl Trait<Type = i64>
4277     [333; 337) 'get2': fn get2<{unknown}, impl Trait<Type = i64>>(T) -> U
4278     [333; 340) 'get2(y)': {unknown}
4279     [338; 339) 'y': impl Trait<Type = i64>
4280     [346; 349) 'get': fn get<S<u64>>(T) -> <T as Trait>::Type
4281     [346; 357) 'get(set(S))': u64
4282     [350; 353) 'set': fn set<S<u64>>(T) -> T
4283     [350; 356) 'set(S)': S<u64>
4284     [354; 355) 'S': S<u64>
4285     [363; 367) 'get2': fn get2<u64, S<u64>>(T) -> U
4286     [363; 375) 'get2(set(S))': u64
4287     [368; 371) 'set': fn set<S<u64>>(T) -> T
4288     [368; 374) 'set(S)': S<u64>
4289     [372; 373) 'S': S<u64>
4290     [381; 385) 'get2': fn get2<str, S<str>>(T) -> U
4291     [381; 395) 'get2(S::<str>)': str
4292     [386; 394) 'S::<str>': S<str>
4293     "###
4294     );
4295 }
4296
4297 #[test]
4298 fn impl_trait_assoc_binding_projection_bug() {
4299     let (db, pos) = TestDB::with_position(
4300         r#"
4301 //- /main.rs crate:main deps:std
4302 pub trait Language {
4303     type Kind;
4304 }
4305 pub enum RustLanguage {}
4306 impl Language for RustLanguage {
4307     type Kind = SyntaxKind;
4308 }
4309 struct SyntaxNode<L> {}
4310 fn foo() -> impl Iterator<Item = SyntaxNode<RustLanguage>> {}
4311
4312 trait Clone {
4313     fn clone(&self) -> Self;
4314 }
4315
4316 fn api_walkthrough() {
4317     for node in foo() {
4318         node.clone()<|>;
4319     }
4320 }
4321
4322 //- /std.rs crate:std
4323 #[prelude_import] use iter::*;
4324 mod iter {
4325     trait IntoIterator {
4326         type Item;
4327     }
4328     trait Iterator {
4329         type Item;
4330     }
4331     impl<T: Iterator> IntoIterator for T {
4332         type Item = <T as Iterator>::Item;
4333     }
4334 }
4335 "#,
4336     );
4337     assert_eq!("{unknown}", type_at_pos(&db, pos));
4338 }
4339
4340 #[test]
4341 fn projection_eq_within_chalk() {
4342     // std::env::set_var("CHALK_DEBUG", "1");
4343     assert_snapshot!(
4344         infer(r#"
4345 trait Trait1 {
4346     type Type;
4347 }
4348 trait Trait2<T> {
4349     fn foo(self) -> T;
4350 }
4351 impl<T, U> Trait2<T> for U where U: Trait1<Type = T> {}
4352
4353 fn test<T: Trait1<Type = u32>>(x: T) {
4354     x.foo();
4355 }
4356 "#),
4357         @r###"
4358     [62; 66) 'self': Self
4359     [164; 165) 'x': T
4360     [170; 186) '{     ...o(); }': ()
4361     [176; 177) 'x': T
4362     [176; 183) 'x.foo()': {unknown}
4363     "###
4364     );
4365 }
4366
4367 #[test]
4368 fn where_clause_trait_in_scope_for_method_resolution() {
4369     let t = type_at(
4370         r#"
4371 //- /main.rs
4372 mod foo {
4373     trait Trait {
4374         fn foo(&self) -> u32 {}
4375     }
4376 }
4377
4378 fn test<T: foo::Trait>(x: T) {
4379     x.foo()<|>;
4380 }
4381 "#,
4382     );
4383     assert_eq!(t, "u32");
4384 }
4385
4386 #[test]
4387 fn super_trait_method_resolution() {
4388     assert_snapshot!(
4389         infer(r#"
4390 mod foo {
4391     trait SuperTrait {
4392         fn foo(&self) -> u32 {}
4393     }
4394 }
4395 trait Trait1: foo::SuperTrait {}
4396 trait Trait2 where Self: foo::SuperTrait {}
4397
4398 fn test<T: Trait1, U: Trait2>(x: T, y: U) {
4399     x.foo();
4400     y.foo();
4401 }
4402 "#),
4403         @r###"
4404     [50; 54) 'self': &Self
4405     [63; 65) '{}': ()
4406     [182; 183) 'x': T
4407     [188; 189) 'y': U
4408     [194; 223) '{     ...o(); }': ()
4409     [200; 201) 'x': T
4410     [200; 207) 'x.foo()': u32
4411     [213; 214) 'y': U
4412     [213; 220) 'y.foo()': u32
4413     "###
4414     );
4415 }
4416
4417 #[test]
4418 fn super_trait_cycle() {
4419     // This just needs to not crash
4420     assert_snapshot!(
4421         infer(r#"
4422 trait A: B {}
4423 trait B: A {}
4424
4425 fn test<T: A>(x: T) {
4426     x.foo();
4427 }
4428 "#),
4429         @r###"
4430     [44; 45) 'x': T
4431     [50; 66) '{     ...o(); }': ()
4432     [56; 57) 'x': T
4433     [56; 63) 'x.foo()': {unknown}
4434     "###
4435     );
4436 }
4437
4438 #[test]
4439 fn super_trait_assoc_type_bounds() {
4440     assert_snapshot!(
4441         infer(r#"
4442 trait SuperTrait { type Type; }
4443 trait Trait where Self: SuperTrait {}
4444
4445 fn get2<U, T: Trait<Type = U>>(t: T) -> U {}
4446 fn set<T: Trait<Type = u64>>(t: T) -> T {t}
4447
4448 struct S<T>;
4449 impl<T> SuperTrait for S<T> { type Type = T; }
4450 impl<T> Trait for S<T> {}
4451
4452 fn test() {
4453     get2(set(S));
4454 }
4455 "#),
4456         @r###"
4457     [103; 104) 't': T
4458     [114; 116) '{}': ()
4459     [146; 147) 't': T
4460     [157; 160) '{t}': T
4461     [158; 159) 't': T
4462     [259; 280) '{     ...S)); }': ()
4463     [265; 269) 'get2': fn get2<u64, S<u64>>(T) -> U
4464     [265; 277) 'get2(set(S))': u64
4465     [270; 273) 'set': fn set<S<u64>>(T) -> T
4466     [270; 276) 'set(S)': S<u64>
4467     [274; 275) 'S': S<u64>
4468     "###
4469     );
4470 }
4471
4472 #[test]
4473 fn fn_trait() {
4474     assert_snapshot!(
4475         infer(r#"
4476 trait FnOnce<Args> {
4477     type Output;
4478
4479     fn call_once(self, args: Args) -> <Self as FnOnce<Args>>::Output;
4480 }
4481
4482 fn test<F: FnOnce(u32, u64) -> u128>(f: F) {
4483     f.call_once((1, 2));
4484 }
4485 "#),
4486         @r###"
4487     [57; 61) 'self': Self
4488     [63; 67) 'args': Args
4489     [150; 151) 'f': F
4490     [156; 184) '{     ...2)); }': ()
4491     [162; 163) 'f': F
4492     [162; 181) 'f.call...1, 2))': {unknown}
4493     [174; 180) '(1, 2)': (u32, u64)
4494     [175; 176) '1': u32
4495     [178; 179) '2': u64
4496     "###
4497     );
4498 }
4499
4500 #[test]
4501 fn closure_1() {
4502     assert_snapshot!(
4503         infer(r#"
4504 #[lang = "fn_once"]
4505 trait FnOnce<Args> {
4506     type Output;
4507 }
4508
4509 enum Option<T> { Some(T), None }
4510 impl<T> Option<T> {
4511     fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Option<U> {}
4512 }
4513
4514 fn test() {
4515     let x = Option::Some(1u32);
4516     x.map(|v| v + 1);
4517     x.map(|_v| 1u64);
4518     let y: Option<i64> = x.map(|_v| 1);
4519 }
4520 "#),
4521         @r###"
4522     [148; 152) 'self': Option<T>
4523     [154; 155) 'f': F
4524     [173; 175) '{}': ()
4525     [189; 308) '{     ... 1); }': ()
4526     [199; 200) 'x': Option<u32>
4527     [203; 215) 'Option::Some': Some<u32>(T) -> Option<T>
4528     [203; 221) 'Option...(1u32)': Option<u32>
4529     [216; 220) '1u32': u32
4530     [227; 228) 'x': Option<u32>
4531     [227; 243) 'x.map(...v + 1)': Option<u32>
4532     [233; 242) '|v| v + 1': |u32| -> u32
4533     [234; 235) 'v': u32
4534     [237; 238) 'v': u32
4535     [237; 242) 'v + 1': u32
4536     [241; 242) '1': u32
4537     [249; 250) 'x': Option<u32>
4538     [249; 265) 'x.map(... 1u64)': Option<u64>
4539     [255; 264) '|_v| 1u64': |u32| -> u64
4540     [256; 258) '_v': u32
4541     [260; 264) '1u64': u64
4542     [275; 276) 'y': Option<i64>
4543     [292; 293) 'x': Option<u32>
4544     [292; 305) 'x.map(|_v| 1)': Option<i64>
4545     [298; 304) '|_v| 1': |u32| -> i64
4546     [299; 301) '_v': u32
4547     [303; 304) '1': i64
4548     "###
4549     );
4550 }
4551
4552 #[test]
4553 fn closure_2() {
4554     assert_snapshot!(
4555         infer(r#"
4556 trait FnOnce<Args> {
4557     type Output;
4558 }
4559
4560 fn test<F: FnOnce(u32) -> u64>(f: F) {
4561     f(1);
4562     let g = |v| v + 1;
4563     g(1u64);
4564     let h = |v| 1u128 + v;
4565 }
4566 "#),
4567         @r###"
4568     [73; 74) 'f': F
4569     [79; 155) '{     ...+ v; }': ()
4570     [85; 86) 'f': F
4571     [85; 89) 'f(1)': {unknown}
4572     [87; 88) '1': i32
4573     [99; 100) 'g': |u64| -> i32
4574     [103; 112) '|v| v + 1': |u64| -> i32
4575     [104; 105) 'v': u64
4576     [107; 108) 'v': u64
4577     [107; 112) 'v + 1': i32
4578     [111; 112) '1': i32
4579     [118; 119) 'g': |u64| -> i32
4580     [118; 125) 'g(1u64)': i32
4581     [120; 124) '1u64': u64
4582     [135; 136) 'h': |u128| -> u128
4583     [139; 152) '|v| 1u128 + v': |u128| -> u128
4584     [140; 141) 'v': u128
4585     [143; 148) '1u128': u128
4586     [143; 152) '1u128 + v': u128
4587     [151; 152) 'v': u128
4588     "###
4589     );
4590 }
4591
4592 #[test]
4593 fn closure_as_argument_inference_order() {
4594     assert_snapshot!(
4595         infer(r#"
4596 #[lang = "fn_once"]
4597 trait FnOnce<Args> {
4598     type Output;
4599 }
4600
4601 fn foo1<T, U, F: FnOnce(T) -> U>(x: T, f: F) -> U {}
4602 fn foo2<T, U, F: FnOnce(T) -> U>(f: F, x: T) -> U {}
4603
4604 struct S;
4605 impl S {
4606     fn method(self) -> u64;
4607
4608     fn foo1<T, U, F: FnOnce(T) -> U>(self, x: T, f: F) -> U {}
4609     fn foo2<T, U, F: FnOnce(T) -> U>(self, f: F, x: T) -> U {}
4610 }
4611
4612 fn test() {
4613     let x1 = foo1(S, |s| s.method());
4614     let x2 = foo2(|s| s.method(), S);
4615     let x3 = S.foo1(S, |s| s.method());
4616     let x4 = S.foo2(|s| s.method(), S);
4617 }
4618 "#),
4619         @r###"
4620     [95; 96) 'x': T
4621     [101; 102) 'f': F
4622     [112; 114) '{}': ()
4623     [148; 149) 'f': F
4624     [154; 155) 'x': T
4625     [165; 167) '{}': ()
4626     [202; 206) 'self': S
4627     [254; 258) 'self': S
4628     [260; 261) 'x': T
4629     [266; 267) 'f': F
4630     [277; 279) '{}': ()
4631     [317; 321) 'self': S
4632     [323; 324) 'f': F
4633     [329; 330) 'x': T
4634     [340; 342) '{}': ()
4635     [356; 515) '{     ... S); }': ()
4636     [366; 368) 'x1': u64
4637     [371; 375) 'foo1': fn foo1<S, u64, |S| -> u64>(T, F) -> U
4638     [371; 394) 'foo1(S...hod())': u64
4639     [376; 377) 'S': S
4640     [379; 393) '|s| s.method()': |S| -> u64
4641     [380; 381) 's': S
4642     [383; 384) 's': S
4643     [383; 393) 's.method()': u64
4644     [404; 406) 'x2': u64
4645     [409; 413) 'foo2': fn foo2<S, u64, |S| -> u64>(F, T) -> U
4646     [409; 432) 'foo2(|...(), S)': u64
4647     [414; 428) '|s| s.method()': |S| -> u64
4648     [415; 416) 's': S
4649     [418; 419) 's': S
4650     [418; 428) 's.method()': u64
4651     [430; 431) 'S': S
4652     [442; 444) 'x3': u64
4653     [447; 448) 'S': S
4654     [447; 472) 'S.foo1...hod())': u64
4655     [454; 455) 'S': S
4656     [457; 471) '|s| s.method()': |S| -> u64
4657     [458; 459) 's': S
4658     [461; 462) 's': S
4659     [461; 471) 's.method()': u64
4660     [482; 484) 'x4': u64
4661     [487; 488) 'S': S
4662     [487; 512) 'S.foo2...(), S)': u64
4663     [494; 508) '|s| s.method()': |S| -> u64
4664     [495; 496) 's': S
4665     [498; 499) 's': S
4666     [498; 508) 's.method()': u64
4667     [510; 511) 'S': S
4668     "###
4669     );
4670 }
4671
4672 #[test]
4673 fn unselected_projection_in_trait_env_1() {
4674     let t = type_at(
4675         r#"
4676 //- /main.rs
4677 trait Trait {
4678     type Item;
4679 }
4680
4681 trait Trait2 {
4682     fn foo(&self) -> u32;
4683 }
4684
4685 fn test<T: Trait>() where T::Item: Trait2 {
4686     let x: T::Item = no_matter;
4687     x.foo()<|>;
4688 }
4689 "#,
4690     );
4691     assert_eq!(t, "u32");
4692 }
4693
4694 #[test]
4695 fn unselected_projection_in_trait_env_2() {
4696     let t = type_at(
4697         r#"
4698 //- /main.rs
4699 trait Trait<T> {
4700     type Item;
4701 }
4702
4703 trait Trait2 {
4704     fn foo(&self) -> u32;
4705 }
4706
4707 fn test<T, U>() where T::Item: Trait2, T: Trait<U::Item>, U: Trait<()> {
4708     let x: T::Item = no_matter;
4709     x.foo()<|>;
4710 }
4711 "#,
4712     );
4713     assert_eq!(t, "u32");
4714 }
4715
4716 #[test]
4717 fn trait_impl_self_ty() {
4718     let t = type_at(
4719         r#"
4720 //- /main.rs
4721 trait Trait<T> {
4722    fn foo(&self);
4723 }
4724
4725 struct S;
4726
4727 impl Trait<Self> for S {}
4728
4729 fn test() {
4730     S.foo()<|>;
4731 }
4732 "#,
4733     );
4734     assert_eq!(t, "()");
4735 }
4736
4737 #[test]
4738 fn trait_impl_self_ty_cycle() {
4739     let t = type_at(
4740         r#"
4741 //- /main.rs
4742 trait Trait {
4743    fn foo(&self);
4744 }
4745
4746 struct S<T>;
4747
4748 impl Trait for S<Self> {}
4749
4750 fn test() {
4751     S.foo()<|>;
4752 }
4753 "#,
4754     );
4755     assert_eq!(t, "{unknown}");
4756 }
4757
4758 #[test]
4759 fn unselected_projection_in_trait_env_cycle_1() {
4760     let t = type_at(
4761         r#"
4762 //- /main.rs
4763 trait Trait {
4764     type Item;
4765 }
4766
4767 trait Trait2<T> {}
4768
4769 fn test<T: Trait>() where T: Trait2<T::Item> {
4770     let x: T::Item = no_matter<|>;
4771 }
4772 "#,
4773     );
4774     // this is a legitimate cycle
4775     assert_eq!(t, "{unknown}");
4776 }
4777
4778 #[test]
4779 fn unselected_projection_in_trait_env_cycle_2() {
4780     let t = type_at(
4781         r#"
4782 //- /main.rs
4783 trait Trait<T> {
4784     type Item;
4785 }
4786
4787 fn test<T, U>() where T: Trait<U::Item>, U: Trait<T::Item> {
4788     let x: T::Item = no_matter<|>;
4789 }
4790 "#,
4791     );
4792     // this is a legitimate cycle
4793     assert_eq!(t, "{unknown}");
4794 }
4795
4796 fn type_at_pos(db: &TestDB, pos: FilePosition) -> String {
4797     let file = db.parse(pos.file_id).ok().unwrap();
4798     let expr = algo::find_node_at_offset::<ast::Expr>(file.syntax(), pos.offset).unwrap();
4799
4800     let module = db.module_for_file(pos.file_id);
4801     let crate_def_map = db.crate_def_map(module.krate);
4802     for decl in crate_def_map[module.local_id].scope.declarations() {
4803         if let ModuleDefId::FunctionId(func) = decl {
4804             let (_body, source_map) = db.body_with_source_map(func.into());
4805             if let Some(expr_id) = source_map.node_expr(InFile::new(pos.file_id.into(), &expr)) {
4806                 let infer = db.infer(func.into());
4807                 let ty = &infer[expr_id];
4808                 return ty.display(db).to_string();
4809             }
4810         }
4811     }
4812     panic!("Can't find expression")
4813 }
4814
4815 fn type_at(content: &str) -> String {
4816     let (db, file_pos) = TestDB::with_position(content);
4817     type_at_pos(&db, file_pos)
4818 }
4819
4820 fn infer(content: &str) -> String {
4821     let (db, file_id) = TestDB::with_single_file(content);
4822
4823     let mut acc = String::new();
4824
4825     let mut infer_def = |inference_result: Arc<InferenceResult>,
4826                          body_source_map: Arc<BodySourceMap>| {
4827         let mut types = Vec::new();
4828
4829         for (pat, ty) in inference_result.type_of_pat.iter() {
4830             let syntax_ptr = match body_source_map.pat_syntax(pat) {
4831                 Some(sp) => {
4832                     sp.map(|ast| ast.either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr()))
4833                 }
4834                 None => continue,
4835             };
4836             types.push((syntax_ptr, ty));
4837         }
4838
4839         for (expr, ty) in inference_result.type_of_expr.iter() {
4840             let syntax_ptr = match body_source_map.expr_syntax(expr) {
4841                 Some(sp) => {
4842                     sp.map(|ast| ast.either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr()))
4843                 }
4844                 None => continue,
4845             };
4846             types.push((syntax_ptr, ty));
4847         }
4848
4849         // sort ranges for consistency
4850         types.sort_by_key(|(src_ptr, _)| {
4851             (src_ptr.value.range().start(), src_ptr.value.range().end())
4852         });
4853         for (src_ptr, ty) in &types {
4854             let node = src_ptr.value.to_node(&src_ptr.file_syntax(&db));
4855
4856             let (range, text) = if let Some(self_param) = ast::SelfParam::cast(node.clone()) {
4857                 (self_param.self_kw_token().text_range(), "self".to_string())
4858             } else {
4859                 (src_ptr.value.range(), node.text().to_string().replace("\n", " "))
4860             };
4861             let macro_prefix = if src_ptr.file_id != file_id.into() { "!" } else { "" };
4862             write!(
4863                 acc,
4864                 "{}{} '{}': {}\n",
4865                 macro_prefix,
4866                 range,
4867                 ellipsize(text, 15),
4868                 ty.display(&db)
4869             )
4870             .unwrap();
4871         }
4872     };
4873
4874     let module = db.module_for_file(file_id);
4875     let crate_def_map = db.crate_def_map(module.krate);
4876
4877     let mut defs: Vec<DefWithBodyId> = Vec::new();
4878     visit_module(&db, &crate_def_map, module.local_id, &mut |it| defs.push(it));
4879     defs.sort_by_key(|def| match def {
4880         DefWithBodyId::FunctionId(it) => {
4881             it.lookup(&db).ast_id.to_node(&db).syntax().text_range().start()
4882         }
4883         DefWithBodyId::ConstId(it) => {
4884             it.lookup(&db).ast_id.to_node(&db).syntax().text_range().start()
4885         }
4886         DefWithBodyId::StaticId(it) => {
4887             it.lookup(&db).ast_id.to_node(&db).syntax().text_range().start()
4888         }
4889     });
4890     for def in defs {
4891         let (_body, source_map) = db.body_with_source_map(def);
4892         let infer = db.infer(def);
4893         infer_def(infer, source_map);
4894     }
4895
4896     acc.truncate(acc.trim_end().len());
4897     acc
4898 }
4899
4900 fn visit_module(
4901     db: &TestDB,
4902     crate_def_map: &CrateDefMap,
4903     module_id: LocalModuleId,
4904     cb: &mut dyn FnMut(DefWithBodyId),
4905 ) {
4906     for decl in crate_def_map[module_id].scope.declarations() {
4907         match decl {
4908             ModuleDefId::FunctionId(it) => cb(it.into()),
4909             ModuleDefId::ConstId(it) => cb(it.into()),
4910             ModuleDefId::StaticId(it) => cb(it.into()),
4911             ModuleDefId::TraitId(it) => {
4912                 let trait_data = db.trait_data(it);
4913                 for &(_, item) in trait_data.items.iter() {
4914                     match item {
4915                         AssocItemId::FunctionId(it) => cb(it.into()),
4916                         AssocItemId::ConstId(it) => cb(it.into()),
4917                         AssocItemId::TypeAliasId(_) => (),
4918                     }
4919                 }
4920             }
4921             ModuleDefId::ModuleId(it) => visit_module(db, crate_def_map, it.local_id, cb),
4922             _ => (),
4923         }
4924     }
4925     for &impl_id in crate_def_map[module_id].impls.iter() {
4926         let impl_data = db.impl_data(impl_id);
4927         for &item in impl_data.items.iter() {
4928             match item {
4929                 AssocItemId::FunctionId(it) => cb(it.into()),
4930                 AssocItemId::ConstId(it) => cb(it.into()),
4931                 AssocItemId::TypeAliasId(_) => (),
4932             }
4933         }
4934     }
4935 }
4936
4937 fn ellipsize(mut text: String, max_len: usize) -> String {
4938     if text.len() <= max_len {
4939         return text;
4940     }
4941     let ellipsis = "...";
4942     let e_len = ellipsis.len();
4943     let mut prefix_len = (max_len - e_len) / 2;
4944     while !text.is_char_boundary(prefix_len) {
4945         prefix_len += 1;
4946     }
4947     let mut suffix_len = max_len - e_len - prefix_len;
4948     while !text.is_char_boundary(text.len() - suffix_len) {
4949         suffix_len += 1;
4950     }
4951     text.replace_range(prefix_len..text.len() - suffix_len, ellipsis);
4952     text
4953 }
4954
4955 #[test]
4956 fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
4957     let (mut db, pos) = TestDB::with_position(
4958         "
4959         //- /lib.rs
4960         fn foo() -> i32 {
4961             <|>1 + 1
4962         }
4963     ",
4964     );
4965     {
4966         let events = db.log_executed(|| {
4967             let module = db.module_for_file(pos.file_id);
4968             let crate_def_map = db.crate_def_map(module.krate);
4969             visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
4970                 db.infer(def);
4971             });
4972         });
4973         assert!(format!("{:?}", events).contains("infer"))
4974     }
4975
4976     let new_text = "
4977         fn foo() -> i32 {
4978             1
4979             +
4980             1
4981         }
4982     "
4983     .to_string();
4984
4985     db.query_mut(ra_db::FileTextQuery).set(pos.file_id, Arc::new(new_text));
4986
4987     {
4988         let events = db.log_executed(|| {
4989             let module = db.module_for_file(pos.file_id);
4990             let crate_def_map = db.crate_def_map(module.krate);
4991             visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
4992                 db.infer(def);
4993             });
4994         });
4995         assert!(!format!("{:?}", events).contains("infer"), "{:#?}", events)
4996     }
4997 }
4998
4999 #[test]
5000 fn no_such_field_diagnostics() {
5001     let diagnostics = TestDB::with_files(
5002         r"
5003         //- /lib.rs
5004         struct S { foo: i32, bar: () }
5005         impl S {
5006             fn new() -> S {
5007                 S {
5008                     foo: 92,
5009                     baz: 62,
5010                 }
5011             }
5012         }
5013         ",
5014     )
5015     .diagnostics();
5016
5017     assert_snapshot!(diagnostics, @r###"
5018     "baz: 62": no such field
5019     "{\n            foo: 92,\n            baz: 62,\n        }": Missing structure fields:
5020     - bar
5021     "###
5022     );
5023 }
5024
5025 #[test]
5026 fn infer_builtin_macros_line() {
5027     assert_snapshot!(
5028         infer(r#"
5029 #[rustc_builtin_macro]
5030 macro_rules! line {() => {}}
5031
5032 fn main() {
5033     let x = line!();
5034 }
5035 "#),
5036         @r###"
5037     ![0; 1) '6': i32
5038     [64; 88) '{     ...!(); }': ()
5039     [74; 75) 'x': i32
5040     "###
5041     );
5042 }
5043
5044 #[test]
5045 fn infer_builtin_macros_file() {
5046     assert_snapshot!(
5047         infer(r#"
5048 #[rustc_builtin_macro]
5049 macro_rules! file {() => {}}
5050
5051 fn main() {
5052     let x = file!();
5053 }
5054 "#),
5055         @r###"
5056     ![0; 2) '""': &str
5057     [64; 88) '{     ...!(); }': ()
5058     [74; 75) 'x': &str
5059     "###
5060     );
5061 }
5062
5063 #[test]
5064 fn infer_builtin_macros_column() {
5065     assert_snapshot!(
5066         infer(r#"
5067 #[rustc_builtin_macro]
5068 macro_rules! column {() => {}}
5069
5070 fn main() {
5071     let x = column!();
5072 }
5073 "#),
5074         @r###"
5075     ![0; 2) '13': i32
5076     [66; 92) '{     ...!(); }': ()
5077     [76; 77) 'x': i32
5078     "###
5079     );
5080 }