Fix test fallout, and add some rather comprehensive tests.

Author: Ariel Ben-Yehuda

src/test/compile-fail/cast-ptr-to-int-const.rs

@@ -0,0 +1,15 @@
+// Copyright 2015 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 main() {
+    const X: u32 = main as u32; //~ ERROR E0018
+    const Y: u32 = 0;
+    const Z: u32 = &Y as *const u32 as u32; //~ ERROR E0018
+}

src/test/compile-fail/cast-rfc0401.rs

@@ -0,0 +1,70 @@
+// Copyright 2015 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 illegal_cast<U:?Sized,V:?Sized>(u: *const U) -> *const V
+{
+    u as *const V //~ ERROR vtable kinds
+}
+
+fn illegal_cast_2<U:?Sized>(u: *const U) -> *const str
+{
+    u as *const str //~ ERROR vtable kinds
+}
+
+trait Foo { fn foo(&self) {} }
+impl<T> Foo for T {}
+
+enum E {
+    A, B
+}
+
+fn main()
+{
+    let f: f32 = 1.2;
+    let v = 0 as *const u8;
+    let fat_v : *const [u8] = unsafe { &*(0 as *const [u8; 1])};
+    let foo: &Foo = &f;
+
+    let _ = v as &u8; //~ ERROR non-scalar
+    let _ = v as E; //~ ERROR non-scalar
+    let _ = v as fn(); //~ ERROR non-scalar
+    let _ = v as (u32,); //~ ERROR non-scalar
+    let _ = Some(&v) as *const u8; //~ ERROR non-scalar
+
+    let _ = v as f32; //~ ERROR through a usize first
+    let _ = main as f64; //~ ERROR through a usize first
+    let _ = &v as usize; //~ ERROR through a raw pointer first
+    let _ = f as *const u8; //~ ERROR through a usize first
+    let _ = 3 as bool; //~ ERROR compare with zero
+    let _ = E::A as bool; //~ ERROR compare with zero
+    let _ = 0x61u32 as char; //~ ERROR only `u8` can be cast
+
+    let _ = false as f32; //~ ERROR through an integer first
+    let _ = E::A as f32; //~ ERROR through an integer first
+    let _ = 'a' as f32; //~ ERROR through an integer first
+
+    let _ = false as *const u8; //~ ERROR through a usize first
+    let _ = E::A as *const u8; //~ ERROR through a usize first
+    let _ = 'a' as *const u8; //~ ERROR through a usize first
+
+    let _ = 42usize as *const [u8]; //~ ERROR illegal cast
+    let _ = v as *const [u8]; //~ ERROR illegal cast
+    let _ = fat_v as *const Foo; //~ ERROR illegal cast
+    let _ = foo as *const str; //~ ERROR illegal cast
+    let _ = foo as *mut str; //~ ERROR illegal cast
+    let _ = main as *mut str; //~ ERROR illegal cast
+    let _ = &f as *mut f32; //~ ERROR illegal cast
+    let _ = &f as *const f64; //~ ERROR illegal cast
+    let _ = fat_v as usize; //~ ERROR through a raw pointer first
+
+    // check no error cascade
+    let _ = main.f as *const u32; //~ ERROR attempted access of field
+
+}

src/test/compile-fail/cast-to-bare-fn.rs

@@ -13,7 +13,7 @@ fn foo(_x: isize) { }
 fn main() {
     let v: u64 = 5;
     let x = foo as extern "C" fn() -> isize;
-    //~^ ERROR mismatched types
+    //~^ ERROR non-scalar cast
     let y = v as extern "Rust" fn(isize) -> (isize, isize);
     //~^ ERROR non-scalar cast
     y(x());

src/test/compile-fail/const-cast-different-types.rs

@@ -9,18 +9,8 @@
 // except according to those terms.
 
 static a: &'static str = "foo";
-static b: *const u8 = a as *const u8;
-//~^ ERROR mismatched types
-//~| expected *const u8
-//~| found &'static str
-//~| expected u8
-//~| found str
-static c: *const u8 = &a as *const u8;
-//~^ ERROR mismatched types
-//~| expected *const u8
-//~| found &&'static str
-//~| expected u8
-//~| found &-ptr
+static b: *const u8 = a as *const u8; //~ ERROR illegal cast
+static c: *const u8 = &a as *const u8; //~ ERROR illegal cast
 
 fn main() {
 }

src/test/compile-fail/fat-ptr-cast.rs

@@ -8,10 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Make sure casts between thin pointer <-> fat pointer are illegal.
-
-pub trait Trait {}
-
 fn main() {
     let a: &[i32] = &[1, 2, 3];
     let b: Box<[i32]> = Box::new([1, 2, 3]);

src/test/compile-fail/issue-14845.rs

@@ -15,18 +15,8 @@ struct X {
 
 fn main() {
     let x = X { a: [0] };
-    let _f = &x.a as *mut u8;
-    //~^ ERROR mismatched types
-    //~| expected `*mut u8`
-    //~| found `&[u8; 1]`
-    //~| expected u8
-    //~| found array of 1 elements
+    let _f = &x.a as *mut u8; //~ ERROR illegal cast
 
     let local: [u8; 1] = [0];
-    let _v = &local as *mut u8;
-    //~^ ERROR mismatched types
-    //~| expected `*mut u8`
-    //~| found `&[u8; 1]`
-    //~| expected u8,
-    //~| found array of 1 elements
+    let _v = &local as *mut u8; //~ ERROR illegal cast
 }

src/test/compile-fail/issue-17444.rs

@@ -14,5 +14,5 @@ enum Test {
 
 fn main() {
     let _x = Test::Foo as *const isize;
-    //~^ ERROR illegal cast; cast through an integer first: `Test` as `*const isize`
+    //~^ ERROR illegal cast; cast through a usize first: `Test` as `*const isize`
 }

src/test/compile-fail/issue-21554.rs

@@ -11,5 +11,5 @@
 struct Inches(i32);
 
 fn main() {
-    Inches as f32; //~ ERROR illegal cast; cast through an integer first
+    Inches as f32; //~ ERROR illegal cast; cast through a usize first
 }

src/test/compile-fail/typeck-cast-pointer-to-float.rs

@@ -11,5 +11,5 @@
 fn main() {
     let x : i16 = 22;
     ((&x) as *const i16) as f32;
-    //~^ ERROR illegal cast; cast through an integer first: `*const i16` as `f32`
+    //~^ ERROR illegal cast; cast through a usize first: `*const i16` as `f32`
 }

src/test/compile-fail/vector-cast-weirdness.rs

@@ -28,7 +28,7 @@ fn main() {
     let mut x1 = X { y: [0, 0] };
 
     // This is still an error since we don't allow casts from &mut [T; n] to *mut T.
-    let p1: *mut u8 = &mut x1.y as *mut _;  //~ ERROR mismatched types
+    let p1: *mut u8 = &mut x1.y as *mut _;  //~ ERROR illegal cast
     let t1: *mut [u8; 2] = &mut x1.y as *mut _;
     let h1: *mut [u8; 2] = &mut x1.y as *mut [u8; 2];
 }