Implement BindingMode for pattern matching.

Implement `BindingMode` for pattern matching, so that types can be
correctly inferred using match ergonomics. The binding mode defaults to
`Move` (referred to as 'BindingMode::BindByValue` in rustc), and is
updated by automatic dereferencing of the value being matched.

crates/ra_hir/src/ty/tests.rs

@@ -756,6 +756,8 @@ fn test(x: &str, y: isize) {
 fn infer_pattern() {
     assert_snapshot_matches!(
         infer(r#"
+struct A<T>(T);
+
 fn test(x: &i32) {
     let y = x;
     let &z = x;
@@ -772,6 +774,12 @@ fn test(x: &i32) {
 
     let lambda = |a: u64, b, c: i32| { a + b; c };
 
+    let A(n) = &A(1);
+    let A(n) = &mut A(1);
+
+    let v = &(1, &2);
+    let (_, &w) = v;
+
     let ref ref_to_x = x;
     let mut mut_x = x;
     let ref mut mut_ref_to_x = x;
@@ -779,53 +787,76 @@ fn test(x: &i32) {
 }
 "#),
         @r###"
-[9; 10) 'x': &i32
-[18; 369) '{     ...o_x; }': ()
-[28; 29) 'y': &i32
-[32; 33) 'x': &i32
-[43; 45) '&z': &i32
-[44; 45) 'z': i32
-[48; 49) 'x': &i32
-[59; 60) 'a': i32
-[63; 64) 'z': i32
-[74; 80) '(c, d)': (i32, &str)
-[75; 76) 'c': i32
-[78; 79) 'd': &str
-[83; 95) '(1, "hello")': (i32, &str)
-[84; 85) '1': i32
-[87; 94) '"hello"': &str
-[102; 152) 'for (e...     }': ()
-[106; 112) '(e, f)': ({unknown}, {unknown})
-[107; 108) 'e': {unknown}
-[110; 111) 'f': {unknown}
-[116; 125) 'some_iter': {unknown}
-[126; 152) '{     ...     }': ()
-[140; 141) 'g': {unknown}
-[144; 145) 'e': {unknown}
-[158; 205) 'if let...     }': ()
-[165; 170) '[val]': {unknown}
-[173; 176) 'opt': {unknown}
-[177; 205) '{     ...     }': ()
-[191; 192) 'h': {unknown}
-[195; 198) 'val': {unknown}
-[215; 221) 'lambda': {unknown}
-[224; 256) '|a: u6...b; c }': {unknown}
-[225; 226) 'a': u64
-[233; 234) 'b': u64
-[236; 237) 'c': i32
-[244; 256) '{ a + b; c }': i32
-[246; 247) 'a': u64
-[246; 251) 'a + b': u64
+[26; 27) 'x': &i32
+[35; 479) '{     ...o_x; }': ()
+[45; 46) 'y': &i32
+[49; 50) 'x': &i32
+[60; 62) '&z': &i32
+[61; 62) 'z': i32
+[65; 66) 'x': &i32
+[76; 77) 'a': i32
+[80; 81) 'z': i32
+[91; 97) '(c, d)': (i32, &str)
+[92; 93) 'c': i32
+[95; 96) 'd': &str
+[100; 112) '(1, "hello")': (i32, &str)
+[101; 102) '1': i32
+[104; 111) '"hello"': &str
+[119; 169) 'for (e...     }': ()
+[123; 129) '(e, f)': ({unknown}, {unknown})
+[124; 125) 'e': {unknown}
+[127; 128) 'f': {unknown}
+[133; 142) 'some_iter': {unknown}
+[143; 169) '{     ...     }': ()
+[157; 158) 'g': {unknown}
+[161; 162) 'e': {unknown}
+[175; 222) 'if let...     }': ()
+[182; 187) '[val]': {unknown}
+[190; 193) 'opt': {unknown}
+[194; 222) '{     ...     }': ()
+[208; 209) 'h': {unknown}
+[212; 215) 'val': {unknown}
+[232; 238) 'lambda': {unknown}
+[241; 273) '|a: u6...b; c }': {unknown}
+[242; 243) 'a': u64
 [250; 251) 'b': u64
 [253; 254) 'c': i32
-[267; 279) 'ref ref_to_x': &&i32
-[282; 283) 'x': &i32
-[293; 302) 'mut mut_x': &i32
-[305; 306) 'x': &i32
-[316; 336) 'ref mu...f_to_x': &mut &i32
-[339; 340) 'x': &i32
-[350; 351) 'k': &mut &i32
-[354; 366) 'mut_ref_to_x': &mut &i32"###
+[261; 273) '{ a + b; c }': i32
+[263; 264) 'a': u64
+[263; 268) 'a + b': u64
+[267; 268) 'b': u64
+[270; 271) 'c': i32
+[284; 288) 'A(n)': A<i32>
+[286; 287) 'n': &i32
+[291; 296) '&A(1)': &A<i32>
+[292; 293) 'A': A<i32>(T) -> A<T>
+[292; 296) 'A(1)': A<i32>
+[294; 295) '1': i32
+[306; 310) 'A(n)': A<i32>
+[308; 309) 'n': &mut i32
+[313; 322) '&mut A(1)': &mut A<i32>
+[318; 319) 'A': A<i32>(T) -> A<T>
+[318; 322) 'A(1)': A<i32>
+[320; 321) '1': i32
+[333; 334) 'v': &(i32, &i32)
+[337; 345) '&(1, &2)': &(i32, &i32)
+[338; 345) '(1, &2)': (i32, &i32)
+[339; 340) '1': i32
+[342; 344) '&2': &i32
+[343; 344) '2': i32
+[355; 362) '(_, &w)': (i32, &i32)
+[356; 357) '_': i32
+[359; 361) '&w': &i32
+[360; 361) 'w': i32
+[365; 366) 'v': &(i32, &i32)
+[377; 389) 'ref ref_to_x': &&i32
+[392; 393) 'x': &i32
+[403; 412) 'mut mut_x': &i32
+[415; 416) 'x': &i32
+[426; 446) 'ref mu...f_to_x': &mut &i32
+[449; 450) 'x': &i32
+[460; 461) 'k': &mut &i32
+[464; 476) 'mut_ref_to_x': &mut &i32"###
     );
 }