Fix test fallout, and add some rather comprehensive tests.

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

@@ -9,9 +9,6 @@
 // except according to those terms.
 
 // Make sure casts between thin-pointer <-> fat pointer obey RFC401
-
-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];
 }

src/test/run-pass/cast-enum-with-dtor.rs

@@ -0,0 +1,44 @@
+// 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.
+
+#![allow(dead_code)]
+
+// check dtor calling order when casting enums.
+
+use std::sync::atomic;
+use std::sync::atomic::Ordering;
+use std::mem;
+
+enum E {
+    A = 0,
+    B = 1,
+    C = 2
+}
+
+static FLAG: atomic::AtomicUsize = atomic::ATOMIC_USIZE_INIT;
+
+impl Drop for E {
+    fn drop(&mut self) {
+        // avoid dtor loop
+        unsafe { mem::forget(mem::replace(self, E::B)) };
+
+        FLAG.store(FLAG.load(Ordering::SeqCst)+1, Ordering::SeqCst);
+    }
+}
+
+fn main() {
+    assert_eq!(FLAG.load(Ordering::SeqCst), 0);
+    {
+        let e = E::C;
+        assert_eq!(e as u32, 2);
+        assert_eq!(FLAG.load(Ordering::SeqCst), 0);
+    }
+    assert_eq!(FLAG.load(Ordering::SeqCst), 1);
+}

src/test/run-pass/cast-rfc0401-vtable-kinds.rs

@@ -0,0 +1,52 @@
+// 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.
+
+trait Foo<T> {
+    fn foo(&self, _: T) -> u32 { 42 }
+}
+
+trait Bar {
+    fn bar(&self) { println!("Bar!"); }
+}
+
+impl<T> Foo<T> for () {}
+impl Foo<u32> for u32 { fn foo(&self, _: u32) -> u32 { self+43 } }
+impl Bar for () {}
+
+unsafe fn fool<'a>(t: *const (Foo<u32>+'a)) -> u32 {
+    let bar : *const Bar = t as *const Bar;
+    let foo_e : *const Foo<u16> = t as *const _;
+    let r_1 = foo_e as *mut Foo<u32>;
+
+    (&*r_1).foo(0)*(&*(bar as *const Foo<u32>)).foo(0)
+}
+
+#[repr(C)]
+struct FooS<T:?Sized>(T);
+#[repr(C)]
+struct BarS<T:?Sized>(T);
+
+fn foo_to_bar<T:?Sized>(u: *const FooS<T>) -> *const BarS<T> {
+    u as *const BarS<T>
+}
+
+fn main() {
+    let x = 4u32;
+    let y : &Foo<u32> = &x;
+    let fl = unsafe { fool(y as *const Foo<u32>) };
+    assert_eq!(fl, (43+4)*(43+4));
+
+    let s = FooS([0,1,2]);
+    let u: &FooS<[u32]> = &s;
+    let u: *const FooS<[u32]> = u;
+    let bar_ref : *const BarS<[u32]> = foo_to_bar(u);
+    let z : &BarS<[u32]> = unsafe{&*bar_ref};
+    assert_eq!(&z.0, &[0,1,2]);
+}

src/test/run-pass/cast-rfc0401.rs

@@ -0,0 +1,169 @@
+// 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.
+
+#![allow(dead_code)]
+
+use std::vec;
+
+enum Simple {
+    A,
+    B,
+    C
+}
+
+enum Valued {
+    H8=163,
+    Z=0,
+    X=256,
+    H7=67,
+}
+
+enum ValuedSigned {
+    M1=-1,
+    P1=1
+}
+
+fn main()
+{
+    // coercion-cast
+    let mut it = vec![137].into_iter();
+    let itr: &mut vec::IntoIter<u32> = &mut it;
+    assert_eq!((itr as &mut Iterator<Item=u32>).next(), Some(137));
+    assert_eq!((itr as &mut Iterator<Item=u32>).next(), None);
+
+    assert_eq!(Some(4u32) as Option<u32>, Some(4u32));
+    assert_eq!((1u32,2u32) as (u32,u32), (1,2));
+
+    // this isn't prim-int-cast. Check that it works.
+    assert_eq!(false as bool, false);
+    assert_eq!(true as bool, true);
+
+    // numeric-cast
+    let l: u64 = 0x8090a0b0c0d0e0f0;
+    let lsz: usize = l as usize;
+    assert_eq!(l as u32, 0xc0d0e0f0);
+
+    // numeric-cast
+    assert_eq!(l as u8, 0xf0);
+    assert_eq!(l as i8,-0x10);
+    assert_eq!(l as u32, 0xc0d0e0f0);
+    assert_eq!(l as u32 as usize as u32, l as u32);
+    assert_eq!(l as i32,-0x3f2f1f10);
+    assert_eq!(l as i32 as isize as i32, l as i32);
+    assert_eq!(l as i64,-0x7f6f5f4f3f2f1f10);
+
+    assert_eq!(0 as f64, 0f64);
+    assert_eq!(1 as f64, 1f64);
+
+    assert_eq!(l as f64, 9264081114510712022f64);
+
+    assert_eq!(l as i64 as f64, -9182662959198838444f64);
+//  float overflow : needs fixing
+//  assert_eq!(l as f32 as i64 as u64, 9264082620822882088u64);
+//  assert_eq!(l as i64 as f32 as i64, 9182664080220408446i64);
+
+    assert_eq!(4294967040f32 as u32, 0xffffff00u32);
+    assert_eq!(1.844674407370955e19f64 as u64, 0xfffffffffffff800u64);
+
+    assert_eq!(9.223372036854775e18f64 as i64, 0x7ffffffffffffc00i64);
+    assert_eq!(-9.223372036854776e18f64 as i64, 0x8000000000000000u64 as i64);
+
+
+    // addr-ptr-cast/ptr-addr-cast (thin ptr)
+    let p: *const [u8; 1] = lsz as *const [u8; 1];
+    assert_eq!(p as usize, lsz);
+
+    // ptr-ptr-cast (thin ptr)
+    let w: *const () = p as *const ();
+    assert_eq!(w as usize, lsz);
+
+    // ptr-ptr-cast (fat->thin)
+    let u: *const [u8] = unsafe{&*p};    assert_eq!(u as *const u8, p as *const u8);
+
+    // ptr-ptr-cast (both vk=Length)
+    let mut l : [u8; 2] = [0,1];
+    let w: *mut [u16; 2] = &mut l as *mut [u8; 2] as *mut _;
+    let w: *mut [u16] = unsafe {&mut *w};
+    let w_u8 : *const [u8] = w as *const [u8];
+    assert_eq!(unsafe{&*w_u8}, &l);
+
+    let s: *mut str = w as *mut str;
+    let l_via_str = unsafe{&*(s as *const [u8])};
+    assert_eq!(&l, l_via_str);
+
+    // enum-cast
+    assert_eq!(Simple::A as u8, 0);
+    assert_eq!(Simple::B as u8, 1);
+
+    assert_eq!(Valued::H8 as i8, -93);
+    assert_eq!(Valued::H7 as i8, 67);
+    assert_eq!(Valued::Z as i8, 0);
+
+    assert_eq!(Valued::H8 as u8, 163);
+    assert_eq!(Valued::H7 as u8, 67);
+    assert_eq!(Valued::Z as u8, 0);
+
+    assert_eq!(Valued::H8 as u16, 163);
+    assert_eq!(Valued::Z as u16, 0);
+    assert_eq!(Valued::H8 as u16, 163);
+    assert_eq!(Valued::Z as u16, 0);
+
+    assert_eq!(ValuedSigned::M1 as u16, 65535);
+    assert_eq!(ValuedSigned::M1 as i16, -1);
+    assert_eq!(ValuedSigned::P1 as u16, 1);
+    assert_eq!(ValuedSigned::P1 as i16, 1);
+
+    // prim-int-cast
+    assert_eq!(false as u16, 0);
+    assert_eq!(true as u16, 1);
+    assert_eq!(false as i64, 0);
+    assert_eq!(true as i64, 1);
+    assert_eq!('a' as u32, 0x61);
+    assert_eq!('a' as u16, 0x61);
+    assert_eq!('a' as u8, 0x61);
+    assert_eq!('א' as u8, 0xd0);
+    assert_eq!('א' as u16, 0x5d0);
+    assert_eq!('א' as u32, 0x5d0);
+    assert_eq!('🐵' as u8, 0x35);
+    assert_eq!('🐵' as u16, 0xf435);
+    assert_eq!('🐵' as u32, 0x1f435);
+    assert_eq!('英' as i16, -0x7d0f);
+    assert_eq!('英' as u16, 0x82f1);
+
+    // u8-char-cast
+    assert_eq!(0x61 as char, 'a');
+    assert_eq!(0u8 as char, '\0');
+    assert_eq!(0xd7 as char, '×');
+
+    // array-ptr-cast
+    let x = [1,2,3];
+    let first : *const u32 = &x[0];
+
+    assert_eq!(first, &x as *const _);
+    assert_eq!(first, &x as *const u32);
+
+    // fptr-addr-cast
+    fn foo() {
+        println!("foo!");
+    }
+    fn bar() {
+        println!("bar!");
+    }
+
+    assert!(foo as usize != bar as usize);
+
+    assert_eq!(foo as i16, foo as usize as i16);
+
+    // fptr-ptr-cast
+
+    assert_eq!(foo as *const u8 as usize, foo as usize);
+    assert!(foo as *const u32 != first);
+}
+fn foo() { }

src/test/run-pass/supported-cast.rs

@@ -181,7 +181,6 @@ pub fn main() {
 
   println!("{:?}", true as isize);
   println!("{:?}", true as usize);
-  println!("{:?}", true as *const libc::FILE);
   println!("{:?}", true as i8);
   println!("{:?}", true as i16);
   println!("{:?}", true as i32);
@@ -190,8 +189,6 @@ pub fn main() {
   println!("{:?}", true as u16);
   println!("{:?}", true as u32);
   println!("{:?}", true as u64);
-  println!("{:?}", true as f32);
-  println!("{:?}", true as f64);
 
   println!("{:?}", 1f32 as isize);
   println!("{:?}", 1f32 as usize);