Merged migrated compile-fail tests and ui tests. Fixes #46841.

6 files changed, 1307 insertions, 0 deletions

diff --git a/src/test/ui/numeric/numeric-cast-2.rs b/src/test/ui/numeric/numeric-cast-2.rs
new file mode 100644
index 00000000000..2092b6bce37
--- /dev/null
+++ b/src/test/ui/numeric/numeric-cast-2.rs
@@ -0,0 +1,21 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn foo() -> i32 {
+    4
+}
+fn main() {
+    let x: u16 = foo();
+    //~^ ERROR mismatched types
+    let y: i64 = x + x;
+    //~^ ERROR mismatched types
+    let z: i32 = x + x;
+    //~^ ERROR mismatched types
+}
diff --git a/src/test/ui/numeric/numeric-cast-2.stderr b/src/test/ui/numeric/numeric-cast-2.stderr
new file mode 100644
index 00000000000..3d485583717
--- /dev/null
+++ b/src/test/ui/numeric/numeric-cast-2.stderr
@@ -0,0 +1,21 @@
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast-2.rs:15:18
+   |
+LL |     let x: u16 = foo();
+   |                  ^^^^^ expected u16, found i32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast-2.rs:17:18
+   |
+LL |     let y: i64 = x + x;
+   |                  ^^^^^ expected i64, found u16
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast-2.rs:19:18
+   |
+LL |     let z: i32 = x + x;
+   |                  ^^^^^ expected i32, found u16
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/src/test/ui/numeric/numeric-cast.rs b/src/test/ui/numeric/numeric-cast.rs
new file mode 100644
index 00000000000..69bfdfa94b1
--- /dev/null
+++ b/src/test/ui/numeric/numeric-cast.rs
@@ -0,0 +1,320 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+fn foo<N>(_x: N) {}
+
+fn main() {
+    let x_usize: usize = 1;
+    let x_u64: u64 = 2;
+    let x_u32: u32 = 3;
+    let x_u16: u16 = 4;
+    let x_u8: u8 = 5;
+    let x_isize: isize = 6;
+    let x_i64: i64 = 7;
+    let x_i32: i32 = 8;
+    let x_i16: i16 = 9;
+    let x_i8: i8 = 10;
+    let x_f64: f64 = 11.0;
+    let x_f32: f32 = 12.0;
+
+    foo::<usize>(x_usize);
+    foo::<usize>(x_u64);
+    //~^ ERROR mismatched types
+    foo::<usize>(x_u32);
+    //~^ ERROR mismatched types
+    foo::<usize>(x_u16);
+    //~^ ERROR mismatched types
+    foo::<usize>(x_u8);
+    //~^ ERROR mismatched types
+    foo::<usize>(x_isize);
+    //~^ ERROR mismatched types
+    foo::<usize>(x_i64);
+    //~^ ERROR mismatched types
+    foo::<usize>(x_i32);
+    //~^ ERROR mismatched types
+    foo::<usize>(x_i16);
+    //~^ ERROR mismatched types
+    foo::<usize>(x_i8);
+    //~^ ERROR mismatched types
+    foo::<usize>(x_f64);
+    //~^ ERROR mismatched types
+    foo::<usize>(x_f32);
+    //~^ ERROR mismatched types
+
+    foo::<isize>(x_usize);
+    //~^ ERROR mismatched types
+    foo::<isize>(x_u64);
+    //~^ ERROR mismatched types
+    foo::<isize>(x_u32);
+    //~^ ERROR mismatched types
+    foo::<isize>(x_u16);
+    //~^ ERROR mismatched types
+    foo::<isize>(x_u8);
+    //~^ ERROR mismatched types
+    foo::<isize>(x_isize);
+    foo::<isize>(x_i64);
+    //~^ ERROR mismatched types
+    foo::<isize>(x_i32);
+    //~^ ERROR mismatched types
+    foo::<isize>(x_i16);
+    //~^ ERROR mismatched types
+    foo::<isize>(x_i8);
+    //~^ ERROR mismatched types
+    foo::<isize>(x_f64);
+    //~^ ERROR mismatched types
+    foo::<isize>(x_f32);
+    //~^ ERROR mismatched types
+
+    foo::<u64>(x_usize);
+    //~^ ERROR mismatched types
+    foo::<u64>(x_u64);
+    foo::<u64>(x_u32);
+    //~^ ERROR mismatched types
+    foo::<u64>(x_u16);
+    //~^ ERROR mismatched types
+    foo::<u64>(x_u8);
+    //~^ ERROR mismatched types
+    foo::<u64>(x_isize);
+    //~^ ERROR mismatched types
+    foo::<u64>(x_i64);
+    //~^ ERROR mismatched types
+    foo::<u64>(x_i32);
+    //~^ ERROR mismatched types
+    foo::<u64>(x_i16);
+    //~^ ERROR mismatched types
+    foo::<u64>(x_i8);
+    //~^ ERROR mismatched types
+    foo::<u64>(x_f64);
+    //~^ ERROR mismatched types
+    foo::<u64>(x_f32);
+    //~^ ERROR mismatched types
+
+    foo::<i64>(x_usize);
+    //~^ ERROR mismatched types
+    foo::<i64>(x_u64);
+    //~^ ERROR mismatched types
+    foo::<i64>(x_u32);
+    //~^ ERROR mismatched types
+    foo::<i64>(x_u16);
+    //~^ ERROR mismatched types
+    foo::<i64>(x_u8);
+    //~^ ERROR mismatched types
+    foo::<i64>(x_isize);
+    //~^ ERROR mismatched types
+    foo::<i64>(x_i64);
+    foo::<i64>(x_i32);
+    //~^ ERROR mismatched types
+    foo::<i64>(x_i16);
+    //~^ ERROR mismatched types
+    foo::<i64>(x_i8);
+    //~^ ERROR mismatched types
+    foo::<i64>(x_f64);
+    //~^ ERROR mismatched types
+    foo::<i64>(x_f32);
+    //~^ ERROR mismatched types
+
+    foo::<u32>(x_usize);
+    //~^ ERROR mismatched types
+    foo::<u32>(x_u64);
+    //~^ ERROR mismatched types
+    foo::<u32>(x_u32);
+    foo::<u32>(x_u16);
+    //~^ ERROR mismatched types
+    foo::<u32>(x_u8);
+    //~^ ERROR mismatched types
+    foo::<u32>(x_isize);
+    //~^ ERROR mismatched types
+    foo::<u32>(x_i64);
+    //~^ ERROR mismatched types
+    foo::<u32>(x_i32);
+    //~^ ERROR mismatched types
+    foo::<u32>(x_i16);
+    //~^ ERROR mismatched types
+    foo::<u32>(x_i8);
+    //~^ ERROR mismatched types
+    foo::<u32>(x_f64);
+    //~^ ERROR mismatched types
+    foo::<u32>(x_f32);
+    //~^ ERROR mismatched types
+
+    foo::<i32>(x_usize);
+    //~^ ERROR mismatched types
+    foo::<i32>(x_u64);
+    //~^ ERROR mismatched types
+    foo::<i32>(x_u32);
+    //~^ ERROR mismatched types
+    foo::<i32>(x_u16);
+    //~^ ERROR mismatched types
+    foo::<i32>(x_u8);
+    //~^ ERROR mismatched types
+    foo::<i32>(x_isize);
+    //~^ ERROR mismatched types
+    foo::<i32>(x_i64);
+    //~^ ERROR mismatched types
+    foo::<i32>(x_i32);
+    foo::<i32>(x_i16);
+    //~^ ERROR mismatched types
+    foo::<i32>(x_i8);
+    //~^ ERROR mismatched types
+    foo::<i32>(x_f64);
+    //~^ ERROR mismatched types
+    foo::<i32>(x_f32);
+    //~^ ERROR mismatched types
+
+    foo::<u16>(x_usize);
+    //~^ ERROR mismatched types
+    foo::<u16>(x_u64);
+    //~^ ERROR mismatched types
+    foo::<u16>(x_u32);
+    //~^ ERROR mismatched types
+    foo::<u16>(x_u16);
+    foo::<u16>(x_u8);
+    //~^ ERROR mismatched types
+    foo::<u16>(x_isize);
+    //~^ ERROR mismatched types
+    foo::<u16>(x_i64);
+    //~^ ERROR mismatched types
+    foo::<u16>(x_i32);
+    //~^ ERROR mismatched types
+    foo::<u16>(x_i16);
+    //~^ ERROR mismatched types
+    foo::<u16>(x_i8);
+    //~^ ERROR mismatched types
+    foo::<u16>(x_f64);
+    //~^ ERROR mismatched types
+    foo::<u16>(x_f32);
+    //~^ ERROR mismatched types
+
+    foo::<i16>(x_usize);
+    //~^ ERROR mismatched types
+    foo::<i16>(x_u64);
+    //~^ ERROR mismatched types
+    foo::<i16>(x_u32);
+    //~^ ERROR mismatched types
+    foo::<i16>(x_u16);
+    //~^ ERROR mismatched types
+    foo::<i16>(x_u8);
+    //~^ ERROR mismatched types
+    foo::<i16>(x_isize);
+    //~^ ERROR mismatched types
+    foo::<i16>(x_i64);
+    //~^ ERROR mismatched types
+    foo::<i16>(x_i32);
+    //~^ ERROR mismatched types
+    foo::<i16>(x_i16);
+    foo::<i16>(x_i8);
+    //~^ ERROR mismatched types
+    foo::<i16>(x_f64);
+    //~^ ERROR mismatched types
+    foo::<i16>(x_f32);
+    //~^ ERROR mismatched types
+
+    foo::<u8>(x_usize);
+    //~^ ERROR mismatched types
+    foo::<u8>(x_u64);
+    //~^ ERROR mismatched types
+    foo::<u8>(x_u32);
+    //~^ ERROR mismatched types
+    foo::<u8>(x_u16);
+    //~^ ERROR mismatched types
+    foo::<u8>(x_u8);
+    foo::<u8>(x_isize);
+    //~^ ERROR mismatched types
+    foo::<u8>(x_i64);
+    //~^ ERROR mismatched types
+    foo::<u8>(x_i32);
+    //~^ ERROR mismatched types
+    foo::<u8>(x_i16);
+    //~^ ERROR mismatched types
+    foo::<u8>(x_i8);
+    //~^ ERROR mismatched types
+    foo::<u8>(x_f64);
+    //~^ ERROR mismatched types
+    foo::<u8>(x_f32);
+    //~^ ERROR mismatched types
+
+    foo::<i8>(x_usize);
+    //~^ ERROR mismatched types
+    foo::<i8>(x_u64);
+    //~^ ERROR mismatched types
+    foo::<i8>(x_u32);
+    //~^ ERROR mismatched types
+    foo::<i8>(x_u16);
+    //~^ ERROR mismatched types
+    foo::<i8>(x_u8);
+    //~^ ERROR mismatched types
+    foo::<i8>(x_isize);
+    //~^ ERROR mismatched types
+    foo::<i8>(x_i64);
+    //~^ ERROR mismatched types
+    foo::<i8>(x_i32);
+    //~^ ERROR mismatched types
+    foo::<i8>(x_i16);
+    //~^ ERROR mismatched types
+    foo::<i8>(x_i8);
+    foo::<i8>(x_f64);
+    //~^ ERROR mismatched types
+    foo::<i8>(x_f32);
+    //~^ ERROR mismatched types
+
+    foo::<f64>(x_usize);
+    //~^ ERROR mismatched types
+    foo::<f64>(x_u64);
+    //~^ ERROR mismatched types
+    foo::<f64>(x_u32);
+    //~^ ERROR mismatched types
+    foo::<f64>(x_u16);
+    //~^ ERROR mismatched types
+    foo::<f64>(x_u8);
+    //~^ ERROR mismatched types
+    foo::<f64>(x_isize);
+    //~^ ERROR mismatched types
+    foo::<f64>(x_i64);
+    //~^ ERROR mismatched types
+    foo::<f64>(x_i32);
+    //~^ ERROR mismatched types
+    foo::<f64>(x_i16);
+    //~^ ERROR mismatched types
+    foo::<f64>(x_i8);
+    //~^ ERROR mismatched types
+    foo::<f64>(x_f64);
+    foo::<f64>(x_f32);
+    //~^ ERROR mismatched types
+
+    foo::<f32>(x_usize);
+    //~^ ERROR mismatched types
+    foo::<f32>(x_u64);
+    //~^ ERROR mismatched types
+    foo::<f32>(x_u32);
+    //~^ ERROR mismatched types
+    foo::<f32>(x_u16);
+    //~^ ERROR mismatched types
+    foo::<f32>(x_u8);
+    //~^ ERROR mismatched types
+    foo::<f32>(x_isize);
+    //~^ ERROR mismatched types
+    foo::<f32>(x_i64);
+    //~^ ERROR mismatched types
+    foo::<f32>(x_i32);
+    //~^ ERROR mismatched types
+    foo::<f32>(x_i16);
+    //~^ ERROR mismatched types
+    foo::<f32>(x_i8);
+    //~^ ERROR mismatched types
+    foo::<f32>(x_f64);
+    //~^ ERROR mismatched types
+    foo::<f32>(x_f32);
+
+    foo::<u32>(x_u8 as u16);
+    //~^ ERROR mismatched types
+    foo::<i32>(-x_i8);
+    //~^ ERROR mismatched types
+}
diff --git a/src/test/ui/numeric/numeric-cast.stderr b/src/test/ui/numeric/numeric-cast.stderr
new file mode 100644
index 00000000000..4aac65ff4cb
--- /dev/null
+++ b/src/test/ui/numeric/numeric-cast.stderr
@@ -0,0 +1,907 @@
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:29:18
+   |
+LL |     foo::<usize>(x_u64);
+   |                  ^^^^^ expected usize, found u64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:31:18
+   |
+LL |     foo::<usize>(x_u32);
+   |                  ^^^^^ expected usize, found u32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:33:18
+   |
+LL |     foo::<usize>(x_u16);
+   |                  ^^^^^ expected usize, found u16
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:35:18
+   |
+LL |     foo::<usize>(x_u8);
+   |                  ^^^^ expected usize, found u8
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:37:18
+   |
+LL |     foo::<usize>(x_isize);
+   |                  ^^^^^^^ expected usize, found isize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:39:18
+   |
+LL |     foo::<usize>(x_i64);
+   |                  ^^^^^ expected usize, found i64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:41:18
+   |
+LL |     foo::<usize>(x_i32);
+   |                  ^^^^^ expected usize, found i32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:43:18
+   |
+LL |     foo::<usize>(x_i16);
+   |                  ^^^^^ expected usize, found i16
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:45:18
+   |
+LL |     foo::<usize>(x_i8);
+   |                  ^^^^ expected usize, found i8
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:47:18
+   |
+LL |     foo::<usize>(x_f64);
+   |                  ^^^^^ expected usize, found f64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:49:18
+   |
+LL |     foo::<usize>(x_f32);
+   |                  ^^^^^ expected usize, found f32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:52:18
+   |
+LL |     foo::<isize>(x_usize);
+   |                  ^^^^^^^ expected isize, found usize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:54:18
+   |
+LL |     foo::<isize>(x_u64);
+   |                  ^^^^^ expected isize, found u64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:56:18
+   |
+LL |     foo::<isize>(x_u32);
+   |                  ^^^^^ expected isize, found u32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:58:18
+   |
+LL |     foo::<isize>(x_u16);
+   |                  ^^^^^ expected isize, found u16
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:60:18
+   |
+LL |     foo::<isize>(x_u8);
+   |                  ^^^^ expected isize, found u8
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:63:18
+   |
+LL |     foo::<isize>(x_i64);
+   |                  ^^^^^ expected isize, found i64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:65:18
+   |
+LL |     foo::<isize>(x_i32);
+   |                  ^^^^^ expected isize, found i32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:67:18
+   |
+LL |     foo::<isize>(x_i16);
+   |                  ^^^^^ expected isize, found i16
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:69:18
+   |
+LL |     foo::<isize>(x_i8);
+   |                  ^^^^ expected isize, found i8
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:71:18
+   |
+LL |     foo::<isize>(x_f64);
+   |                  ^^^^^ expected isize, found f64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:73:18
+   |
+LL |     foo::<isize>(x_f32);
+   |                  ^^^^^ expected isize, found f32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:76:16
+   |
+LL |     foo::<u64>(x_usize);
+   |                ^^^^^^^ expected u64, found usize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:79:16
+   |
+LL |     foo::<u64>(x_u32);
+   |                ^^^^^ expected u64, found u32
+help: you can cast an `u32` to `u64`, which will zero-extend the source value
+   |
+LL |     foo::<u64>(x_u32.into());
+   |                ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:81:16
+   |
+LL |     foo::<u64>(x_u16);
+   |                ^^^^^ expected u64, found u16
+help: you can cast an `u16` to `u64`, which will zero-extend the source value
+   |
+LL |     foo::<u64>(x_u16.into());
+   |                ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:83:16
+   |
+LL |     foo::<u64>(x_u8);
+   |                ^^^^ expected u64, found u8
+help: you can cast an `u8` to `u64`, which will zero-extend the source value
+   |
+LL |     foo::<u64>(x_u8.into());
+   |                ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:85:16
+   |
+LL |     foo::<u64>(x_isize);
+   |                ^^^^^^^ expected u64, found isize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:87:16
+   |
+LL |     foo::<u64>(x_i64);
+   |                ^^^^^ expected u64, found i64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:89:16
+   |
+LL |     foo::<u64>(x_i32);
+   |                ^^^^^ expected u64, found i32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:91:16
+   |
+LL |     foo::<u64>(x_i16);
+   |                ^^^^^ expected u64, found i16
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:93:16
+   |
+LL |     foo::<u64>(x_i8);
+   |                ^^^^ expected u64, found i8
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:95:16
+   |
+LL |     foo::<u64>(x_f64);
+   |                ^^^^^ expected u64, found f64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:97:16
+   |
+LL |     foo::<u64>(x_f32);
+   |                ^^^^^ expected u64, found f32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:100:16
+   |
+LL |     foo::<i64>(x_usize);
+   |                ^^^^^^^ expected i64, found usize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:102:16
+   |
+LL |     foo::<i64>(x_u64);
+   |                ^^^^^ expected i64, found u64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:104:16
+   |
+LL |     foo::<i64>(x_u32);
+   |                ^^^^^ expected i64, found u32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:106:16
+   |
+LL |     foo::<i64>(x_u16);
+   |                ^^^^^ expected i64, found u16
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:108:16
+   |
+LL |     foo::<i64>(x_u8);
+   |                ^^^^ expected i64, found u8
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:110:16
+   |
+LL |     foo::<i64>(x_isize);
+   |                ^^^^^^^ expected i64, found isize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:113:16
+   |
+LL |     foo::<i64>(x_i32);
+   |                ^^^^^ expected i64, found i32
+help: you can cast an `i32` to `i64`, which will sign-extend the source value
+   |
+LL |     foo::<i64>(x_i32.into());
+   |                ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:115:16
+   |
+LL |     foo::<i64>(x_i16);
+   |                ^^^^^ expected i64, found i16
+help: you can cast an `i16` to `i64`, which will sign-extend the source value
+   |
+LL |     foo::<i64>(x_i16.into());
+   |                ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:117:16
+   |
+LL |     foo::<i64>(x_i8);
+   |                ^^^^ expected i64, found i8
+help: you can cast an `i8` to `i64`, which will sign-extend the source value
+   |
+LL |     foo::<i64>(x_i8.into());
+   |                ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:119:16
+   |
+LL |     foo::<i64>(x_f64);
+   |                ^^^^^ expected i64, found f64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:121:16
+   |
+LL |     foo::<i64>(x_f32);
+   |                ^^^^^ expected i64, found f32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:124:16
+   |
+LL |     foo::<u32>(x_usize);
+   |                ^^^^^^^ expected u32, found usize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:126:16
+   |
+LL |     foo::<u32>(x_u64);
+   |                ^^^^^ expected u32, found u64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:129:16
+   |
+LL |     foo::<u32>(x_u16);
+   |                ^^^^^ expected u32, found u16
+help: you can cast an `u16` to `u32`, which will zero-extend the source value
+   |
+LL |     foo::<u32>(x_u16.into());
+   |                ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:131:16
+   |
+LL |     foo::<u32>(x_u8);
+   |                ^^^^ expected u32, found u8
+help: you can cast an `u8` to `u32`, which will zero-extend the source value
+   |
+LL |     foo::<u32>(x_u8.into());
+   |                ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:133:16
+   |
+LL |     foo::<u32>(x_isize);
+   |                ^^^^^^^ expected u32, found isize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:135:16
+   |
+LL |     foo::<u32>(x_i64);
+   |                ^^^^^ expected u32, found i64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:137:16
+   |
+LL |     foo::<u32>(x_i32);
+   |                ^^^^^ expected u32, found i32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:139:16
+   |
+LL |     foo::<u32>(x_i16);
+   |                ^^^^^ expected u32, found i16
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:141:16
+   |
+LL |     foo::<u32>(x_i8);
+   |                ^^^^ expected u32, found i8
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:143:16
+   |
+LL |     foo::<u32>(x_f64);
+   |                ^^^^^ expected u32, found f64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:145:16
+   |
+LL |     foo::<u32>(x_f32);
+   |                ^^^^^ expected u32, found f32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:148:16
+   |
+LL |     foo::<i32>(x_usize);
+   |                ^^^^^^^ expected i32, found usize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:150:16
+   |
+LL |     foo::<i32>(x_u64);
+   |                ^^^^^ expected i32, found u64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:152:16
+   |
+LL |     foo::<i32>(x_u32);
+   |                ^^^^^ expected i32, found u32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:154:16
+   |
+LL |     foo::<i32>(x_u16);
+   |                ^^^^^ expected i32, found u16
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:156:16
+   |
+LL |     foo::<i32>(x_u8);
+   |                ^^^^ expected i32, found u8
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:158:16
+   |
+LL |     foo::<i32>(x_isize);
+   |                ^^^^^^^ expected i32, found isize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:160:16
+   |
+LL |     foo::<i32>(x_i64);
+   |                ^^^^^ expected i32, found i64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:163:16
+   |
+LL |     foo::<i32>(x_i16);
+   |                ^^^^^ expected i32, found i16
+help: you can cast an `i16` to `i32`, which will sign-extend the source value
+   |
+LL |     foo::<i32>(x_i16.into());
+   |                ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:165:16
+   |
+LL |     foo::<i32>(x_i8);
+   |                ^^^^ expected i32, found i8
+help: you can cast an `i8` to `i32`, which will sign-extend the source value
+   |
+LL |     foo::<i32>(x_i8.into());
+   |                ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:167:16
+   |
+LL |     foo::<i32>(x_f64);
+   |                ^^^^^ expected i32, found f64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:169:16
+   |
+LL |     foo::<i32>(x_f32);
+   |                ^^^^^ expected i32, found f32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:172:16
+   |
+LL |     foo::<u16>(x_usize);
+   |                ^^^^^^^ expected u16, found usize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:174:16
+   |
+LL |     foo::<u16>(x_u64);
+   |                ^^^^^ expected u16, found u64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:176:16
+   |
+LL |     foo::<u16>(x_u32);
+   |                ^^^^^ expected u16, found u32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:179:16
+   |
+LL |     foo::<u16>(x_u8);
+   |                ^^^^ expected u16, found u8
+help: you can cast an `u8` to `u16`, which will zero-extend the source value
+   |
+LL |     foo::<u16>(x_u8.into());
+   |                ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:181:16
+   |
+LL |     foo::<u16>(x_isize);
+   |                ^^^^^^^ expected u16, found isize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:183:16
+   |
+LL |     foo::<u16>(x_i64);
+   |                ^^^^^ expected u16, found i64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:185:16
+   |
+LL |     foo::<u16>(x_i32);
+   |                ^^^^^ expected u16, found i32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:187:16
+   |
+LL |     foo::<u16>(x_i16);
+   |                ^^^^^ expected u16, found i16
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:189:16
+   |
+LL |     foo::<u16>(x_i8);
+   |                ^^^^ expected u16, found i8
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:191:16
+   |
+LL |     foo::<u16>(x_f64);
+   |                ^^^^^ expected u16, found f64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:193:16
+   |
+LL |     foo::<u16>(x_f32);
+   |                ^^^^^ expected u16, found f32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:196:16
+   |
+LL |     foo::<i16>(x_usize);
+   |                ^^^^^^^ expected i16, found usize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:198:16
+   |
+LL |     foo::<i16>(x_u64);
+   |                ^^^^^ expected i16, found u64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:200:16
+   |
+LL |     foo::<i16>(x_u32);
+   |                ^^^^^ expected i16, found u32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:202:16
+   |
+LL |     foo::<i16>(x_u16);
+   |                ^^^^^ expected i16, found u16
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:204:16
+   |
+LL |     foo::<i16>(x_u8);
+   |                ^^^^ expected i16, found u8
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:206:16
+   |
+LL |     foo::<i16>(x_isize);
+   |                ^^^^^^^ expected i16, found isize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:208:16
+   |
+LL |     foo::<i16>(x_i64);
+   |                ^^^^^ expected i16, found i64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:210:16
+   |
+LL |     foo::<i16>(x_i32);
+   |                ^^^^^ expected i16, found i32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:213:16
+   |
+LL |     foo::<i16>(x_i8);
+   |                ^^^^ expected i16, found i8
+help: you can cast an `i8` to `i16`, which will sign-extend the source value
+   |
+LL |     foo::<i16>(x_i8.into());
+   |                ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:215:16
+   |
+LL |     foo::<i16>(x_f64);
+   |                ^^^^^ expected i16, found f64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:217:16
+   |
+LL |     foo::<i16>(x_f32);
+   |                ^^^^^ expected i16, found f32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:220:15
+   |
+LL |     foo::<u8>(x_usize);
+   |               ^^^^^^^ expected u8, found usize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:222:15
+   |
+LL |     foo::<u8>(x_u64);
+   |               ^^^^^ expected u8, found u64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:224:15
+   |
+LL |     foo::<u8>(x_u32);
+   |               ^^^^^ expected u8, found u32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:226:15
+   |
+LL |     foo::<u8>(x_u16);
+   |               ^^^^^ expected u8, found u16
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:229:15
+   |
+LL |     foo::<u8>(x_isize);
+   |               ^^^^^^^ expected u8, found isize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:231:15
+   |
+LL |     foo::<u8>(x_i64);
+   |               ^^^^^ expected u8, found i64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:233:15
+   |
+LL |     foo::<u8>(x_i32);
+   |               ^^^^^ expected u8, found i32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:235:15
+   |
+LL |     foo::<u8>(x_i16);
+   |               ^^^^^ expected u8, found i16
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:237:15
+   |
+LL |     foo::<u8>(x_i8);
+   |               ^^^^ expected u8, found i8
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:239:15
+   |
+LL |     foo::<u8>(x_f64);
+   |               ^^^^^ expected u8, found f64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:241:15
+   |
+LL |     foo::<u8>(x_f32);
+   |               ^^^^^ expected u8, found f32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:244:15
+   |
+LL |     foo::<i8>(x_usize);
+   |               ^^^^^^^ expected i8, found usize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:246:15
+   |
+LL |     foo::<i8>(x_u64);
+   |               ^^^^^ expected i8, found u64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:248:15
+   |
+LL |     foo::<i8>(x_u32);
+   |               ^^^^^ expected i8, found u32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:250:15
+   |
+LL |     foo::<i8>(x_u16);
+   |               ^^^^^ expected i8, found u16
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:252:15
+   |
+LL |     foo::<i8>(x_u8);
+   |               ^^^^ expected i8, found u8
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:254:15
+   |
+LL |     foo::<i8>(x_isize);
+   |               ^^^^^^^ expected i8, found isize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:256:15
+   |
+LL |     foo::<i8>(x_i64);
+   |               ^^^^^ expected i8, found i64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:258:15
+   |
+LL |     foo::<i8>(x_i32);
+   |               ^^^^^ expected i8, found i32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:260:15
+   |
+LL |     foo::<i8>(x_i16);
+   |               ^^^^^ expected i8, found i16
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:263:15
+   |
+LL |     foo::<i8>(x_f64);
+   |               ^^^^^ expected i8, found f64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:265:15
+   |
+LL |     foo::<i8>(x_f32);
+   |               ^^^^^ expected i8, found f32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:268:16
+   |
+LL |     foo::<f64>(x_usize);
+   |                ^^^^^^^ expected f64, found usize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:270:16
+   |
+LL |     foo::<f64>(x_u64);
+   |                ^^^^^ expected f64, found u64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:272:16
+   |
+LL |     foo::<f64>(x_u32);
+   |                ^^^^^ expected f64, found u32
+help: you can cast an `u32` to `f64`, producing the floating point representation of the integer
+   |
+LL |     foo::<f64>(x_u32.into());
+   |                ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:274:16
+   |
+LL |     foo::<f64>(x_u16);
+   |                ^^^^^ expected f64, found u16
+help: you can cast an `u16` to `f64`, producing the floating point representation of the integer
+   |
+LL |     foo::<f64>(x_u16.into());
+   |                ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:276:16
+   |
+LL |     foo::<f64>(x_u8);
+   |                ^^^^ expected f64, found u8
+help: you can cast an `u8` to `f64`, producing the floating point representation of the integer
+   |
+LL |     foo::<f64>(x_u8.into());
+   |                ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:278:16
+   |
+LL |     foo::<f64>(x_isize);
+   |                ^^^^^^^ expected f64, found isize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:280:16
+   |
+LL |     foo::<f64>(x_i64);
+   |                ^^^^^ expected f64, found i64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:282:16
+   |
+LL |     foo::<f64>(x_i32);
+   |                ^^^^^ expected f64, found i32
+help: you can cast an `i32` to `f64`, producing the floating point representation of the integer
+   |
+LL |     foo::<f64>(x_i32.into());
+   |                ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:284:16
+   |
+LL |     foo::<f64>(x_i16);
+   |                ^^^^^ expected f64, found i16
+help: you can cast an `i16` to `f64`, producing the floating point representation of the integer
+   |
+LL |     foo::<f64>(x_i16.into());
+   |                ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:286:16
+   |
+LL |     foo::<f64>(x_i8);
+   |                ^^^^ expected f64, found i8
+help: you can cast an `i8` to `f64`, producing the floating point representation of the integer
+   |
+LL |     foo::<f64>(x_i8.into());
+   |                ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:289:16
+   |
+LL |     foo::<f64>(x_f32);
+   |                ^^^^^ expected f64, found f32
+help: you can cast an `f32` to `f64` in a lossless way
+   |
+LL |     foo::<f64>(x_f32.into());
+   |                ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:292:16
+   |
+LL |     foo::<f32>(x_usize);
+   |                ^^^^^^^ expected f32, found usize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:294:16
+   |
+LL |     foo::<f32>(x_u64);
+   |                ^^^^^ expected f32, found u64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:296:16
+   |
+LL |     foo::<f32>(x_u32);
+   |                ^^^^^ expected f32, found u32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:298:16
+   |
+LL |     foo::<f32>(x_u16);
+   |                ^^^^^ expected f32, found u16
+help: you can cast an `u16` to `f32`, producing the floating point representation of the integer
+   |
+LL |     foo::<f32>(x_u16.into());
+   |                ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:300:16
+   |
+LL |     foo::<f32>(x_u8);
+   |                ^^^^ expected f32, found u8
+help: you can cast an `u8` to `f32`, producing the floating point representation of the integer
+   |
+LL |     foo::<f32>(x_u8.into());
+   |                ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:302:16
+   |
+LL |     foo::<f32>(x_isize);
+   |                ^^^^^^^ expected f32, found isize
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:304:16
+   |
+LL |     foo::<f32>(x_i64);
+   |                ^^^^^ expected f32, found i64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:306:16
+   |
+LL |     foo::<f32>(x_i32);
+   |                ^^^^^ expected f32, found i32
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:308:16
+   |
+LL |     foo::<f32>(x_i16);
+   |                ^^^^^ expected f32, found i16
+help: you can cast an `i16` to `f32`, producing the floating point representation of the integer
+   |
+LL |     foo::<f32>(x_i16.into());
+   |                ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:310:16
+   |
+LL |     foo::<f32>(x_i8);
+   |                ^^^^ expected f32, found i8
+help: you can cast an `i8` to `f32`, producing the floating point representation of the integer
+   |
+LL |     foo::<f32>(x_i8.into());
+   |                ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:312:16
+   |
+LL |     foo::<f32>(x_f64);
+   |                ^^^^^ expected f32, found f64
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:316:16
+   |
+LL |     foo::<u32>(x_u8 as u16);
+   |                ^^^^^^^^^^^ expected u32, found u16
+help: you can cast an `u16` to `u32`, which will zero-extend the source value
+   |
+LL |     foo::<u32>((x_u8 as u16).into());
+   |                ^^^^^^^^^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/numeric-cast.rs:318:16
+   |
+LL |     foo::<i32>(-x_i8);
+   |                ^^^^^ expected i32, found i8
+help: you can cast an `i8` to `i32`, which will sign-extend the source value
+   |
+LL |     foo::<i32>((-x_i8).into());
+   |                ^^^^^^^^^^^^^^
+
+error: aborting due to 134 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/src/test/ui/numeric/numeric-fields.rs b/src/test/ui/numeric/numeric-fields.rs
new file mode 100644
index 00000000000..89d09560369
--- /dev/null
+++ b/src/test/ui/numeric/numeric-fields.rs
@@ -0,0 +1,20 @@
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct S(u8, u16);
+
+fn main() {
+    let s = S{0b1: 10, 0: 11};
+    //~^ ERROR struct `S` has no field named `0b1`
+    match s {
+        S{0: a, 0x1: b, ..} => {}
+        //~^ ERROR does not have a field named `0x1`
+    }
+}
diff --git a/src/test/ui/numeric/numeric-fields.stderr b/src/test/ui/numeric/numeric-fields.stderr
new file mode 100644
index 00000000000..68a87da8ded
--- /dev/null
+++ b/src/test/ui/numeric/numeric-fields.stderr
@@ -0,0 +1,18 @@
+error[E0560]: struct `S` has no field named `0b1`
+  --> $DIR/numeric-fields.rs:14:15
+   |
+LL |     let s = S{0b1: 10, 0: 11};
+   |               ^^^ `S` does not have this field
+   |
+   = note: available fields are: `0`, `1`
+
+error[E0026]: struct `S` does not have a field named `0x1`
+  --> $DIR/numeric-fields.rs:17:17
+   |
+LL |         S{0: a, 0x1: b, ..} => {}
+   |                 ^^^^^^ struct `S` does not have this field
+
+error: aborting due to 2 previous errors
+
+Some errors occurred: E0026, E0560.
+For more information about an error, try `rustc --explain E0026`.