also test unsafe cast intrinsic (happy cases)

diff --git a/tests/run-pass/float.rs b/tests/run-pass/float.rs
index 738df2f6c59e7fba5a74a7e8030b91c6278467c9..4c30cd01c4c00e6a9d0bcfe3f7533f922663e868 100644 (file)
--- a/tests/run-pass/float.rs
+++ b/tests/run-pass/float.rs
@@ -10,6 +10,63 @@ fn assert_eq<T: PartialEq + Debug>(x: T, y: T) {
     assert_eq!(x, y);
 }
 
+trait FloatToInt<Int>: Copy {
+    fn cast(self) -> Int;
+    unsafe fn cast_unchecked(self) -> Int;
+}
+
+impl FloatToInt<i8> for f32 {
+    fn cast(self) -> i8 { self as _ }
+    unsafe fn cast_unchecked(self) -> i8 { self.to_int_unchecked() }
+}
+impl FloatToInt<i32> for f32 {
+    fn cast(self) -> i32 { self as _ }
+    unsafe fn cast_unchecked(self) -> i32 { self.to_int_unchecked() }
+}
+impl FloatToInt<u32> for f32 {
+    fn cast(self) -> u32 { self as _ }
+    unsafe fn cast_unchecked(self) -> u32 { self.to_int_unchecked() }
+}
+impl FloatToInt<i64> for f32 {
+    fn cast(self) -> i64 { self as _ }
+    unsafe fn cast_unchecked(self) -> i64 { self.to_int_unchecked() }
+}
+impl FloatToInt<u64> for f32 {
+    fn cast(self) -> u64 { self as _ }
+    unsafe fn cast_unchecked(self) -> u64 { self.to_int_unchecked() }
+}
+
+impl FloatToInt<i8> for f64 {
+    fn cast(self) -> i8 { self as _ }
+    unsafe fn cast_unchecked(self) -> i8 { self.to_int_unchecked() }
+}
+impl FloatToInt<i32> for f64 {
+    fn cast(self) -> i32 { self as _ }
+    unsafe fn cast_unchecked(self) -> i32 { self.to_int_unchecked() }
+}
+impl FloatToInt<u32> for f64 {
+    fn cast(self) -> u32 { self as _ }
+    unsafe fn cast_unchecked(self) -> u32 { self.to_int_unchecked() }
+}
+impl FloatToInt<i64> for f64 {
+    fn cast(self) -> i64 { self as _ }
+    unsafe fn cast_unchecked(self) -> i64 { self.to_int_unchecked() }
+}
+impl FloatToInt<u64> for f64 {
+    fn cast(self) -> u64 { self as _ }
+    unsafe fn cast_unchecked(self) -> u64 { self.to_int_unchecked() }
+}
+
+/// Test this cast both via `as` and via `approx_unchecked` (i.e., it must not saturate).
+#[track_caller]
+#[inline(never)]
+fn test_cast<F, I>(x: F, y: I)
+    where F: FloatToInt<I>, I: PartialEq + Debug
+{
+    assert_eq!(x.cast(), y);
+    assert_eq!(unsafe { x.cast_unchecked() }, y);
+}
+
 fn main() {
     basic();
     casts();
@@ -50,19 +107,23 @@ fn basic() {
 }
 
 fn casts() {
+    // f32 -> i8
+    test_cast::<f32, i8>(127.99, 127);
+    test_cast::<f32, i8>(-128.99, -128);
+
     // f32 -> i32
-    assert_eq::<i32>(0.0f32 as i32, 0);
-    assert_eq::<i32>(-0.0f32 as i32, 0);
-    assert_eq::<i32>(/*0x1p-149*/ f32::from_bits(0x00000001) as i32, 0);
-    assert_eq::<i32>(/*-0x1p-149*/ f32::from_bits(0x80000001) as i32, 0);
-    assert_eq::<i32>(/*0x1.19999ap+0*/ f32::from_bits(0x3f8ccccd) as i32, 1);
-    assert_eq::<i32>(/*-0x1.19999ap+0*/ f32::from_bits(0xbf8ccccd) as i32, -1);
-    assert_eq::<i32>(1.9f32 as i32, 1);
-    assert_eq::<i32>(-1.9f32 as i32, -1);
-    assert_eq::<i32>(5.0f32 as i32, 5);
-    assert_eq::<i32>(-5.0f32 as i32, -5);
-    assert_eq::<i32>(2147483520.0f32 as i32, 2147483520);
-    assert_eq::<i32>(-2147483648.0f32 as i32, -2147483648);
+    test_cast::<f32, i32>(0.0, 0);
+    test_cast::<f32, i32>(-0.0, 0);
+    test_cast::<f32, i32>(/*0x1p-149*/ f32::from_bits(0x00000001), 0);
+    test_cast::<f32, i32>(/*-0x1p-149*/ f32::from_bits(0x80000001), 0);
+    test_cast::<f32, i32>(/*0x1.19999ap+0*/ f32::from_bits(0x3f8ccccd), 1);
+    test_cast::<f32, i32>(/*-0x1.19999ap+0*/ f32::from_bits(0xbf8ccccd), -1);
+    test_cast::<f32, i32>(1.9, 1);
+    test_cast::<f32, i32>(-1.9, -1);
+    test_cast::<f32, i32>(5.0, 5);
+    test_cast::<f32, i32>(-5.0, -5);
+    test_cast::<f32, i32>(2147483520.0, 2147483520);
+    test_cast::<f32, i32>(-2147483648.0, -2147483648);
     // unrepresentable casts
     assert_eq::<i32>(2147483648.0f32 as i32, i32::MAX);
     assert_eq::<i32>(-2147483904.0f32 as i32, i32::MIN);
@@ -74,19 +135,19 @@ fn casts() {
     assert_eq::<i32>((-f32::NAN) as i32, 0);
 
     // f32 -> u32
-    assert_eq::<u32>(0.0f32 as u32, 0);
-    assert_eq::<u32>(-0.0f32 as u32, 0);
-    assert_eq::<u32>(/*0x1p-149*/ f32::from_bits(0x1) as u32, 0);
-    assert_eq::<u32>(/*-0x1p-149*/ f32::from_bits(0x80000001) as u32, 0);
-    assert_eq::<u32>(/*0x1.19999ap+0*/ f32::from_bits(0x3f8ccccd) as u32, 1);
-    assert_eq::<u32>(1.9f32 as u32, 1);
-    assert_eq::<u32>(5.0f32 as u32, 5);
-    assert_eq::<u32>(2147483648.0f32 as u32, 0x8000_0000);
-    assert_eq::<u32>(4294967040.0f32 as u32, 0u32.wrapping_sub(256));
-    assert_eq::<u32>(/*-0x1.ccccccp-1*/ f32::from_bits(0xbf666666) as u32, 0);
-    assert_eq::<u32>(/*-0x1.fffffep-1*/ f32::from_bits(0xbf7fffff) as u32, 0);
-    assert_eq::<u32>((u32::MAX-127) as f32 as u32, u32::MAX); // rounding loss
-    assert_eq::<u32>((u32::MAX-128) as f32 as u32, u32::MAX-255); // rounding loss
+    test_cast::<f32, u32>(0.0, 0);
+    test_cast::<f32, u32>(-0.0, 0);
+    test_cast::<f32, u32>(/*0x1p-149*/ f32::from_bits(0x1), 0);
+    test_cast::<f32, u32>(/*-0x1p-149*/ f32::from_bits(0x80000001), 0);
+    test_cast::<f32, u32>(/*0x1.19999ap+0*/ f32::from_bits(0x3f8ccccd), 1);
+    test_cast::<f32, u32>(1.9, 1);
+    test_cast::<f32, u32>(5.0, 5);
+    test_cast::<f32, u32>(2147483648.0, 0x8000_0000);
+    test_cast::<f32, u32>(4294967040.0, 0u32.wrapping_sub(256));
+    test_cast::<f32, u32>(/*-0x1.ccccccp-1*/ f32::from_bits(0xbf666666), 0);
+    test_cast::<f32, u32>(/*-0x1.fffffep-1*/ f32::from_bits(0xbf7fffff), 0);
+    test_cast::<f32, u32>((u32::MAX-127) as f32, u32::MAX); // rounding loss
+    test_cast::<f32, u32>((u32::MAX-128) as f32, u32::MAX-255); // rounding loss
     // unrepresentable casts
     assert_eq::<u32>(4294967296.0f32 as u32, u32::MAX);
     assert_eq::<u32>(-5.0f32 as u32, 0);
@@ -98,40 +159,44 @@ fn casts() {
     assert_eq::<u32>((-f32::NAN) as u32, 0);
 
     // f32 -> i64
-    assert_eq::<i64>(4294967296.0f32 as i64, 4294967296);
-    assert_eq::<i64>(-4294967296.0f32 as i64, -4294967296);
-    assert_eq::<i64>(9223371487098961920.0f32 as i64, 9223371487098961920);
-    assert_eq::<i64>(-9223372036854775808.0f32 as i64, -9223372036854775808);
+    test_cast::<f32, i64>(4294967296.0, 4294967296);
+    test_cast::<f32, i64>(-4294967296.0, -4294967296);
+    test_cast::<f32, i64>(9223371487098961920.0, 9223371487098961920);
+    test_cast::<f32, i64>(-9223372036854775808.0, -9223372036854775808);
+
+    // f64 -> i8
+    test_cast::<f64, i8>(127.99, 127);
+    test_cast::<f64, i8>(-128.99, -128);
 
     // f64 -> i32
-    assert_eq::<i32>(0.0f64 as i32, 0);
-    assert_eq::<i32>(-0.0f64 as i32, 0);
-    assert_eq::<i32>(/*0x1.199999999999ap+0*/ f64::from_bits(0x3ff199999999999a) as i32, 1);
-    assert_eq::<i32>(/*-0x1.199999999999ap+0*/ f64::from_bits(0xbff199999999999a) as i32, -1);
-    assert_eq::<i32>(1.9f64 as i32, 1);
-    assert_eq::<i32>(-1.9f64 as i32, -1);
-    assert_eq::<i32>(1e8f64 as i32, 100_000_000);
-    assert_eq::<i32>(2147483647.0f64 as i32, 2147483647);
-    assert_eq::<i32>(-2147483648.0f64 as i32, -2147483648);
+    test_cast::<f64, i32>(0.0, 0);
+    test_cast::<f64, i32>(-0.0, 0);
+    test_cast::<f64, i32>(/*0x1.199999999999ap+0*/ f64::from_bits(0x3ff199999999999a), 1);
+    test_cast::<f64, i32>(/*-0x1.199999999999ap+0*/ f64::from_bits(0xbff199999999999a), -1);
+    test_cast::<f64, i32>(1.9, 1);
+    test_cast::<f64, i32>(-1.9, -1);
+    test_cast::<f64, i32>(1e8, 100_000_000);
+    test_cast::<f64, i32>(2147483647.0, 2147483647);
+    test_cast::<f64, i32>(-2147483648.0, -2147483648);
     // unrepresentable casts
     assert_eq::<i32>(2147483648.0f64 as i32, i32::MAX);
     assert_eq::<i32>(-2147483649.0f64 as i32, i32::MIN);
 
     // f64 -> i64
-    assert_eq::<i64>(0.0f64 as i64, 0);
-    assert_eq::<i64>(-0.0f64 as i64, 0);
-    assert_eq::<i64>(/*0x0.0000000000001p-1022*/ f64::from_bits(0x1) as i64, 0);
-    assert_eq::<i64>(/*-0x0.0000000000001p-1022*/ f64::from_bits(0x8000000000000001) as i64, 0);
-    assert_eq::<i64>(/*0x1.199999999999ap+0*/ f64::from_bits(0x3ff199999999999a) as i64, 1);
-    assert_eq::<i64>(/*-0x1.199999999999ap+0*/ f64::from_bits(0xbff199999999999a) as i64, -1);
-    assert_eq::<i64>(5.0f64 as i64, 5);
-    assert_eq::<i64>(5.9f64 as i64, 5);
-    assert_eq::<i64>(-5.0f64 as i64, -5);
-    assert_eq::<i64>(-5.9f64 as i64, -5);
-    assert_eq::<i64>(4294967296.0f64 as i64, 4294967296);
-    assert_eq::<i64>(-4294967296.0f64 as i64, -4294967296);
-    assert_eq::<i64>(9223372036854774784.0f64 as i64, 9223372036854774784);
-    assert_eq::<i64>(-9223372036854775808.0f64 as i64, -9223372036854775808);
+    test_cast::<f64, i64>(0.0, 0);
+    test_cast::<f64, i64>(-0.0, 0);
+    test_cast::<f64, i64>(/*0x0.0000000000001p-1022*/ f64::from_bits(0x1), 0);
+    test_cast::<f64, i64>(/*-0x0.0000000000001p-1022*/ f64::from_bits(0x8000000000000001), 0);
+    test_cast::<f64, i64>(/*0x1.199999999999ap+0*/ f64::from_bits(0x3ff199999999999a), 1);
+    test_cast::<f64, i64>(/*-0x1.199999999999ap+0*/ f64::from_bits(0xbff199999999999a), -1);
+    test_cast::<f64, i64>(5.0, 5);
+    test_cast::<f64, i64>(5.9, 5);
+    test_cast::<f64, i64>(-5.0, -5);
+    test_cast::<f64, i64>(-5.9, -5);
+    test_cast::<f64, i64>(4294967296.0, 4294967296);
+    test_cast::<f64, i64>(-4294967296.0, -4294967296);
+    test_cast::<f64, i64>(9223372036854774784.0, 9223372036854774784);
+    test_cast::<f64, i64>(-9223372036854775808.0, -9223372036854775808);
     // unrepresentable casts
     assert_eq::<i64>(9223372036854775808.0f64 as i64, i64::MAX);
     assert_eq::<i64>(-9223372036854777856.0f64 as i64, i64::MIN);
@@ -143,14 +208,14 @@ fn casts() {
     assert_eq::<i64>((-f64::NAN) as i64, 0);
 
     // f64 -> u64
-    assert_eq::<u64>(0.0f64 as u64, 0);
-    assert_eq::<u64>(-0.0f64 as u64, 0);
-    assert_eq::<u64>(5.0f64 as u64, 5);
-    assert_eq::<u64>(-5.0f64 as u64, 0);
-    assert_eq::<u64>(1e16f64 as u64, 10000000000000000);
-    assert_eq::<u64>((u64::MAX-1023) as f64 as u64, u64::MAX); // rounding loss
-    assert_eq::<u64>((u64::MAX-1024) as f64 as u64, u64::MAX-2047); // rounding loss
-    assert_eq::<u64>(9223372036854775808.0f64 as u64, 9223372036854775808);
+    test_cast::<f64, u64>(0.0, 0);
+    test_cast::<f64, u64>(-0.0, 0);
+    test_cast::<f64, u64>(5.0, 5);
+    test_cast::<f64, u64>(-5.0, 0);
+    test_cast::<f64, u64>(1e16, 10000000000000000);
+    test_cast::<f64, u64>((u64::MAX-1023) as f64, u64::MAX); // rounding loss
+    test_cast::<f64, u64>((u64::MAX-1024) as f64, u64::MAX-2047); // rounding loss
+    test_cast::<f64, u64>(9223372036854775808.0, 9223372036854775808);
     // unrepresentable casts
     assert_eq::<u64>(18446744073709551616.0f64 as u64, u64::MAX);
     assert_eq::<u64>(f64::MAX as u64, u64::MAX);