mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

stabilize const_float_bits_conv

Browse Source
This commit is contained in:
Ralf Jung 2024-08-25 15:15:15 +02:00
parent 78d5c04d9c
commit 19908ff7a3
17 changed files with 223 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
library/core/src/lib.rs
View File

@ -122,7 +122,6 @@
#![feature(const_cell_into_inner)] #![feature(const_cell_into_inner)]
#![feature(const_eval_select)] #![feature(const_eval_select)]
#![feature(const_exact_div)] #![feature(const_exact_div)]
#![feature(const_float_bits_conv)]
#![feature(const_float_classify)] #![feature(const_float_classify)]
#![feature(const_fmt_arguments_new)] #![feature(const_fmt_arguments_new)]
#![feature(const_hash)] #![feature(const_hash)]
@ -166,6 +165,8 @@
#![feature(coverage_attribute)] #![feature(coverage_attribute)]
#![feature(do_not_recommend)] #![feature(do_not_recommend)]
#![feature(duration_consts_float)] #![feature(duration_consts_float)]
#![feature(f128_const)]
#![feature(f16_const)]
#![feature(internal_impls_macro)] #![feature(internal_impls_macro)]
#![feature(ip)] #![feature(ip)]
#![feature(is_ascii_octdigit)] #![feature(is_ascii_octdigit)]

16
library/core/src/num/f128.rs
View File

@ -914,7 +914,7 @@ pub unsafe fn to_int_unchecked<Int>(self) -> Int
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "f128", issue = "116909")] #[unstable(feature = "f128", issue = "116909")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_unstable(feature = "f128_const", issue = "116909")]
#[must_use = "this returns the result of the operation, without modifying the original"] #[must_use = "this returns the result of the operation, without modifying the original"]
pub const fn to_bits(self) -> u128 { pub const fn to_bits(self) -> u128 {
// SAFETY: `u128` is a plain old datatype so we can always transmute to it. // SAFETY: `u128` is a plain old datatype so we can always transmute to it.
@ -963,7 +963,7 @@ pub const fn to_bits(self) -> u128 {
#[inline] #[inline]
#[must_use] #[must_use]
#[unstable(feature = "f128", issue = "116909")] #[unstable(feature = "f128", issue = "116909")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_unstable(feature = "f128_const", issue = "116909")]
pub const fn from_bits(v: u128) -> Self { pub const fn from_bits(v: u128) -> Self {
// It turns out the safety issues with sNaN were overblown! Hooray! // It turns out the safety issues with sNaN were overblown! Hooray!
// SAFETY: `u128` is a plain old datatype so we can always transmute from it. // SAFETY: `u128` is a plain old datatype so we can always transmute from it.
@ -990,7 +990,7 @@ pub const fn from_bits(v: u128) -> Self {
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "f128", issue = "116909")] #[unstable(feature = "f128", issue = "116909")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_unstable(feature = "f128_const", issue = "116909")]
#[must_use = "this returns the result of the operation, without modifying the original"] #[must_use = "this returns the result of the operation, without modifying the original"]
pub const fn to_be_bytes(self) -> [u8; 16] { pub const fn to_be_bytes(self) -> [u8; 16] {
self.to_bits().to_be_bytes() self.to_bits().to_be_bytes()
@ -1016,7 +1016,7 @@ pub const fn from_bits(v: u128) -> Self {
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "f128", issue = "116909")] #[unstable(feature = "f128", issue = "116909")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_unstable(feature = "f128_const", issue = "116909")]
#[must_use = "this returns the result of the operation, without modifying the original"] #[must_use = "this returns the result of the operation, without modifying the original"]
pub const fn to_le_bytes(self) -> [u8; 16] { pub const fn to_le_bytes(self) -> [u8; 16] {
self.to_bits().to_le_bytes() self.to_bits().to_le_bytes()
@ -1053,7 +1053,7 @@ pub const fn from_bits(v: u128) -> Self {
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "f128", issue = "116909")] #[unstable(feature = "f128", issue = "116909")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_unstable(feature = "f128_const", issue = "116909")]
#[must_use = "this returns the result of the operation, without modifying the original"] #[must_use = "this returns the result of the operation, without modifying the original"]
pub const fn to_ne_bytes(self) -> [u8; 16] { pub const fn to_ne_bytes(self) -> [u8; 16] {
self.to_bits().to_ne_bytes() self.to_bits().to_ne_bytes()
@ -1081,7 +1081,7 @@ pub const fn from_bits(v: u128) -> Self {
#[inline] #[inline]
#[must_use] #[must_use]
#[unstable(feature = "f128", issue = "116909")] #[unstable(feature = "f128", issue = "116909")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_unstable(feature = "f128_const", issue = "116909")]
pub const fn from_be_bytes(bytes: [u8; 16]) -> Self { pub const fn from_be_bytes(bytes: [u8; 16]) -> Self {
Self::from_bits(u128::from_be_bytes(bytes)) Self::from_bits(u128::from_be_bytes(bytes))
} }
@ -1108,7 +1108,7 @@ pub const fn from_bits(v: u128) -> Self {
#[inline] #[inline]
#[must_use] #[must_use]
#[unstable(feature = "f128", issue = "116909")] #[unstable(feature = "f128", issue = "116909")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_unstable(feature = "f128_const", issue = "116909")]
pub const fn from_le_bytes(bytes: [u8; 16]) -> Self { pub const fn from_le_bytes(bytes: [u8; 16]) -> Self {
Self::from_bits(u128::from_le_bytes(bytes)) Self::from_bits(u128::from_le_bytes(bytes))
} }
@ -1145,7 +1145,7 @@ pub const fn from_bits(v: u128) -> Self {
#[inline] #[inline]
#[must_use] #[must_use]
#[unstable(feature = "f128", issue = "116909")] #[unstable(feature = "f128", issue = "116909")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_unstable(feature = "f128_const", issue = "116909")]
pub const fn from_ne_bytes(bytes: [u8; 16]) -> Self { pub const fn from_ne_bytes(bytes: [u8; 16]) -> Self {
Self::from_bits(u128::from_ne_bytes(bytes)) Self::from_bits(u128::from_ne_bytes(bytes))
} }

16
library/core/src/num/f16.rs
View File

@ -925,7 +925,7 @@ pub unsafe fn to_int_unchecked<Int>(self) -> Int
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "f16", issue = "116909")] #[unstable(feature = "f16", issue = "116909")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_unstable(feature = "f16_const", issue = "116909")]
#[must_use = "this returns the result of the operation, without modifying the original"] #[must_use = "this returns the result of the operation, without modifying the original"]
pub const fn to_bits(self) -> u16 { pub const fn to_bits(self) -> u16 {
// SAFETY: `u16` is a plain old datatype so we can always transmute to it. // SAFETY: `u16` is a plain old datatype so we can always transmute to it.
@ -973,7 +973,7 @@ pub const fn to_bits(self) -> u16 {
#[inline] #[inline]
#[must_use] #[must_use]
#[unstable(feature = "f16", issue = "116909")] #[unstable(feature = "f16", issue = "116909")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_unstable(feature = "f16_const", issue = "116909")]
pub const fn from_bits(v: u16) -> Self { pub const fn from_bits(v: u16) -> Self {
// It turns out the safety issues with sNaN were overblown! Hooray! // It turns out the safety issues with sNaN were overblown! Hooray!
// SAFETY: `u16` is a plain old datatype so we can always transmute from it. // SAFETY: `u16` is a plain old datatype so we can always transmute from it.
@ -999,7 +999,7 @@ pub const fn from_bits(v: u16) -> Self {
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "f16", issue = "116909")] #[unstable(feature = "f16", issue = "116909")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_unstable(feature = "f16_const", issue = "116909")]
#[must_use = "this returns the result of the operation, without modifying the original"] #[must_use = "this returns the result of the operation, without modifying the original"]
pub const fn to_be_bytes(self) -> [u8; 2] { pub const fn to_be_bytes(self) -> [u8; 2] {
self.to_bits().to_be_bytes() self.to_bits().to_be_bytes()
@ -1024,7 +1024,7 @@ pub const fn from_bits(v: u16) -> Self {
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "f16", issue = "116909")] #[unstable(feature = "f16", issue = "116909")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_unstable(feature = "f16_const", issue = "116909")]
#[must_use = "this returns the result of the operation, without modifying the original"] #[must_use = "this returns the result of the operation, without modifying the original"]
pub const fn to_le_bytes(self) -> [u8; 2] { pub const fn to_le_bytes(self) -> [u8; 2] {
self.to_bits().to_le_bytes() self.to_bits().to_le_bytes()
@ -1062,7 +1062,7 @@ pub const fn from_bits(v: u16) -> Self {
/// ``` /// ```
#[inline] #[inline]
#[unstable(feature = "f16", issue = "116909")] #[unstable(feature = "f16", issue = "116909")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_unstable(feature = "f16_const", issue = "116909")]
#[must_use = "this returns the result of the operation, without modifying the original"] #[must_use = "this returns the result of the operation, without modifying the original"]
pub const fn to_ne_bytes(self) -> [u8; 2] { pub const fn to_ne_bytes(self) -> [u8; 2] {
self.to_bits().to_ne_bytes() self.to_bits().to_ne_bytes()
@ -1086,7 +1086,7 @@ pub const fn from_bits(v: u16) -> Self {
#[inline] #[inline]
#[must_use] #[must_use]
#[unstable(feature = "f16", issue = "116909")] #[unstable(feature = "f16", issue = "116909")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_unstable(feature = "f16_const", issue = "116909")]
pub const fn from_be_bytes(bytes: [u8; 2]) -> Self { pub const fn from_be_bytes(bytes: [u8; 2]) -> Self {
Self::from_bits(u16::from_be_bytes(bytes)) Self::from_bits(u16::from_be_bytes(bytes))
} }
@ -1109,7 +1109,7 @@ pub const fn from_bits(v: u16) -> Self {
#[inline] #[inline]
#[must_use] #[must_use]
#[unstable(feature = "f16", issue = "116909")] #[unstable(feature = "f16", issue = "116909")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_unstable(feature = "f16_const", issue = "116909")]
pub const fn from_le_bytes(bytes: [u8; 2]) -> Self { pub const fn from_le_bytes(bytes: [u8; 2]) -> Self {
Self::from_bits(u16::from_le_bytes(bytes)) Self::from_bits(u16::from_le_bytes(bytes))
} }
@ -1143,7 +1143,7 @@ pub const fn from_bits(v: u16) -> Self {
#[inline] #[inline]
#[must_use] #[must_use]
#[unstable(feature = "f16", issue = "116909")] #[unstable(feature = "f16", issue = "116909")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_unstable(feature = "f16_const", issue = "116909")]
pub const fn from_ne_bytes(bytes: [u8; 2]) -> Self { pub const fn from_ne_bytes(bytes: [u8; 2]) -> Self {
Self::from_bits(u16::from_ne_bytes(bytes)) Self::from_bits(u16::from_ne_bytes(bytes))
} }

16
library/core/src/num/f32.rs
View File

@ -1115,7 +1115,7 @@ pub unsafe fn to_int_unchecked<Int>(self) -> Int
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
#[stable(feature = "float_bits_conv", since = "1.20.0")] #[stable(feature = "float_bits_conv", since = "1.20.0")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_stable(feature = "const_float_bits_conv", since = "CURRENT_RUSTC_VERSION")]
#[inline] #[inline]
pub const fn to_bits(self) -> u32 { pub const fn to_bits(self) -> u32 {
// SAFETY: `u32` is a plain old datatype so we can always transmute to it. // SAFETY: `u32` is a plain old datatype so we can always transmute to it.
@ -1159,7 +1159,7 @@ pub const fn to_bits(self) -> u32 {
/// assert_eq!(v, 12.5); /// assert_eq!(v, 12.5);
/// ``` /// ```
#[stable(feature = "float_bits_conv", since = "1.20.0")] #[stable(feature = "float_bits_conv", since = "1.20.0")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_stable(feature = "const_float_bits_conv", since = "CURRENT_RUSTC_VERSION")]
#[must_use] #[must_use]
#[inline] #[inline]
pub const fn from_bits(v: u32) -> Self { pub const fn from_bits(v: u32) -> Self {
@ -1183,7 +1183,7 @@ pub const fn from_bits(v: u32) -> Self {
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
#[stable(feature = "float_to_from_bytes", since = "1.40.0")] #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_stable(feature = "const_float_bits_conv", since = "CURRENT_RUSTC_VERSION")]
#[inline] #[inline]
pub const fn to_be_bytes(self) -> [u8; 4] { pub const fn to_be_bytes(self) -> [u8; 4] {
self.to_bits().to_be_bytes() self.to_bits().to_be_bytes()
@ -1204,7 +1204,7 @@ pub const fn from_bits(v: u32) -> Self {
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
#[stable(feature = "float_to_from_bytes", since = "1.40.0")] #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_stable(feature = "const_float_bits_conv", since = "CURRENT_RUSTC_VERSION")]
#[inline] #[inline]
pub const fn to_le_bytes(self) -> [u8; 4] { pub const fn to_le_bytes(self) -> [u8; 4] {
self.to_bits().to_le_bytes() self.to_bits().to_le_bytes()
@ -1238,7 +1238,7 @@ pub const fn from_bits(v: u32) -> Self {
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
#[stable(feature = "float_to_from_bytes", since = "1.40.0")] #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_stable(feature = "const_float_bits_conv", since = "CURRENT_RUSTC_VERSION")]
#[inline] #[inline]
pub const fn to_ne_bytes(self) -> [u8; 4] { pub const fn to_ne_bytes(self) -> [u8; 4] {
self.to_bits().to_ne_bytes() self.to_bits().to_ne_bytes()
@ -1256,7 +1256,7 @@ pub const fn from_bits(v: u32) -> Self {
/// assert_eq!(value, 12.5); /// assert_eq!(value, 12.5);
/// ``` /// ```
#[stable(feature = "float_to_from_bytes", since = "1.40.0")] #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_stable(feature = "const_float_bits_conv", since = "CURRENT_RUSTC_VERSION")]
#[must_use] #[must_use]
#[inline] #[inline]
pub const fn from_be_bytes(bytes: [u8; 4]) -> Self { pub const fn from_be_bytes(bytes: [u8; 4]) -> Self {
@ -1275,7 +1275,7 @@ pub const fn from_bits(v: u32) -> Self {
/// assert_eq!(value, 12.5); /// assert_eq!(value, 12.5);
/// ``` /// ```
#[stable(feature = "float_to_from_bytes", since = "1.40.0")] #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_stable(feature = "const_float_bits_conv", since = "CURRENT_RUSTC_VERSION")]
#[must_use] #[must_use]
#[inline] #[inline]
pub const fn from_le_bytes(bytes: [u8; 4]) -> Self { pub const fn from_le_bytes(bytes: [u8; 4]) -> Self {
@ -1305,7 +1305,7 @@ pub const fn from_bits(v: u32) -> Self {
/// assert_eq!(value, 12.5); /// assert_eq!(value, 12.5);
/// ``` /// ```
#[stable(feature = "float_to_from_bytes", since = "1.40.0")] #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_stable(feature = "const_float_bits_conv", since = "CURRENT_RUSTC_VERSION")]
#[must_use] #[must_use]
#[inline] #[inline]
pub const fn from_ne_bytes(bytes: [u8; 4]) -> Self { pub const fn from_ne_bytes(bytes: [u8; 4]) -> Self {

16
library/core/src/num/f64.rs
View File

@ -1111,7 +1111,7 @@ pub unsafe fn to_int_unchecked<Int>(self) -> Int
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
#[stable(feature = "float_bits_conv", since = "1.20.0")] #[stable(feature = "float_bits_conv", since = "1.20.0")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_stable(feature = "const_float_bits_conv", since = "CURRENT_RUSTC_VERSION")]
#[inline] #[inline]
pub const fn to_bits(self) -> u64 { pub const fn to_bits(self) -> u64 {
// SAFETY: `u64` is a plain old datatype so we can always transmute to it. // SAFETY: `u64` is a plain old datatype so we can always transmute to it.
@ -1155,7 +1155,7 @@ pub const fn to_bits(self) -> u64 {
/// assert_eq!(v, 12.5); /// assert_eq!(v, 12.5);
/// ``` /// ```
#[stable(feature = "float_bits_conv", since = "1.20.0")] #[stable(feature = "float_bits_conv", since = "1.20.0")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_stable(feature = "const_float_bits_conv", since = "CURRENT_RUSTC_VERSION")]
#[must_use] #[must_use]
#[inline] #[inline]
pub const fn from_bits(v: u64) -> Self { pub const fn from_bits(v: u64) -> Self {
@ -1179,7 +1179,7 @@ pub const fn from_bits(v: u64) -> Self {
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
#[stable(feature = "float_to_from_bytes", since = "1.40.0")] #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_stable(feature = "const_float_bits_conv", since = "CURRENT_RUSTC_VERSION")]
#[inline] #[inline]
pub const fn to_be_bytes(self) -> [u8; 8] { pub const fn to_be_bytes(self) -> [u8; 8] {
self.to_bits().to_be_bytes() self.to_bits().to_be_bytes()
@ -1200,7 +1200,7 @@ pub const fn from_bits(v: u64) -> Self {
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
#[stable(feature = "float_to_from_bytes", since = "1.40.0")] #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_stable(feature = "const_float_bits_conv", since = "CURRENT_RUSTC_VERSION")]
#[inline] #[inline]
pub const fn to_le_bytes(self) -> [u8; 8] { pub const fn to_le_bytes(self) -> [u8; 8] {
self.to_bits().to_le_bytes() self.to_bits().to_le_bytes()
@ -1234,7 +1234,7 @@ pub const fn from_bits(v: u64) -> Self {
#[must_use = "this returns the result of the operation, \ #[must_use = "this returns the result of the operation, \
without modifying the original"] without modifying the original"]
#[stable(feature = "float_to_from_bytes", since = "1.40.0")] #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_stable(feature = "const_float_bits_conv", since = "CURRENT_RUSTC_VERSION")]
#[inline] #[inline]
pub const fn to_ne_bytes(self) -> [u8; 8] { pub const fn to_ne_bytes(self) -> [u8; 8] {
self.to_bits().to_ne_bytes() self.to_bits().to_ne_bytes()
@ -1252,7 +1252,7 @@ pub const fn from_bits(v: u64) -> Self {
/// assert_eq!(value, 12.5); /// assert_eq!(value, 12.5);
/// ``` /// ```
#[stable(feature = "float_to_from_bytes", since = "1.40.0")] #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_stable(feature = "const_float_bits_conv", since = "CURRENT_RUSTC_VERSION")]
#[must_use] #[must_use]
#[inline] #[inline]
pub const fn from_be_bytes(bytes: [u8; 8]) -> Self { pub const fn from_be_bytes(bytes: [u8; 8]) -> Self {
@ -1271,7 +1271,7 @@ pub const fn from_bits(v: u64) -> Self {
/// assert_eq!(value, 12.5); /// assert_eq!(value, 12.5);
/// ``` /// ```
#[stable(feature = "float_to_from_bytes", since = "1.40.0")] #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_stable(feature = "const_float_bits_conv", since = "CURRENT_RUSTC_VERSION")]
#[must_use] #[must_use]
#[inline] #[inline]
pub const fn from_le_bytes(bytes: [u8; 8]) -> Self { pub const fn from_le_bytes(bytes: [u8; 8]) -> Self {
@ -1301,7 +1301,7 @@ pub const fn from_bits(v: u64) -> Self {
/// assert_eq!(value, 12.5); /// assert_eq!(value, 12.5);
/// ``` /// ```
#[stable(feature = "float_to_from_bytes", since = "1.40.0")] #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
#[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] #[rustc_const_stable(feature = "const_float_bits_conv", since = "CURRENT_RUSTC_VERSION")]
#[must_use] #[must_use]
#[inline] #[inline]
pub const fn from_ne_bytes(bytes: [u8; 8]) -> Self { pub const fn from_ne_bytes(bytes: [u8; 8]) -> Self {

6
src/tools/clippy/clippy_lints/src/transmute/mod.rs
View File

@ -619,10 +619,10 @@ fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
| transmute_ref_to_ref::check(cx, e, from_ty, to_ty, arg, const_context) | transmute_ref_to_ref::check(cx, e, from_ty, to_ty, arg, const_context)
| transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, arg, &self.msrv) | transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, arg, &self.msrv)
| transmute_int_to_bool::check(cx, e, from_ty, to_ty, arg) | transmute_int_to_bool::check(cx, e, from_ty, to_ty, arg)
| transmute_int_to_float::check(cx, e, from_ty, to_ty, arg, const_context) | transmute_int_to_float::check(cx, e, from_ty, to_ty, arg)
| transmute_int_to_non_zero::check(cx, e, from_ty, to_ty, arg) | transmute_int_to_non_zero::check(cx, e, from_ty, to_ty, arg)
| transmute_float_to_int::check(cx, e, from_ty, to_ty, arg, const_context) | transmute_float_to_int::check(cx, e, from_ty, to_ty, arg)
| transmute_num_to_bytes::check(cx, e, from_ty, to_ty, arg, const_context) | transmute_num_to_bytes::check(cx, e, from_ty, to_ty, arg)
| (unsound_collection_transmute::check(cx, e, from_ty, to_ty) | (unsound_collection_transmute::check(cx, e, from_ty, to_ty)
|| transmute_undefined_repr::check(cx, e, from_ty, to_ty)) || transmute_undefined_repr::check(cx, e, from_ty, to_ty))
| (eager_transmute::check(cx, e, arg, from_ty, to_ty)); | (eager_transmute::check(cx, e, arg, from_ty, to_ty));

3
src/tools/clippy/clippy_lints/src/transmute/transmute_float_to_int.rs
View File

@ -15,10 +15,9 @@ pub(super) fn check<'tcx>(
from_ty: Ty<'tcx>, from_ty: Ty<'tcx>,
to_ty: Ty<'tcx>, to_ty: Ty<'tcx>,
mut arg: &'tcx Expr<'_>, mut arg: &'tcx Expr<'_>,
const_context: bool,
) -> bool { ) -> bool {
match (&from_ty.kind(), &to_ty.kind()) { match (&from_ty.kind(), &to_ty.kind()) {
(ty::Float(float_ty), ty::Int(_) | ty::Uint(_)) if !const_context => { (ty::Float(float_ty), ty::Int(_) | ty::Uint(_)) => {
span_lint_and_then( span_lint_and_then(
cx, cx,
TRANSMUTE_FLOAT_TO_INT, TRANSMUTE_FLOAT_TO_INT,

3
src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_float.rs
View File

@ -14,10 +14,9 @@ pub(super) fn check<'tcx>(
from_ty: Ty<'tcx>, from_ty: Ty<'tcx>,
to_ty: Ty<'tcx>, to_ty: Ty<'tcx>,
arg: &'tcx Expr<'_>, arg: &'tcx Expr<'_>,
const_context: bool,
) -> bool { ) -> bool {
match (&from_ty.kind(), &to_ty.kind()) { match (&from_ty.kind(), &to_ty.kind()) {
(ty::Int(_) | ty::Uint(_), ty::Float(_)) if !const_context => { (ty::Int(_) | ty::Uint(_), ty::Float(_)) => {
span_lint_and_then( span_lint_and_then(
cx, cx,
TRANSMUTE_INT_TO_FLOAT, TRANSMUTE_INT_TO_FLOAT,

6
src/tools/clippy/clippy_lints/src/transmute/transmute_num_to_bytes.rs
View File

@ -14,18 +14,12 @@ pub(super) fn check<'tcx>(
from_ty: Ty<'tcx>, from_ty: Ty<'tcx>,
to_ty: Ty<'tcx>, to_ty: Ty<'tcx>,
arg: &'tcx Expr<'_>, arg: &'tcx Expr<'_>,
const_context: bool,
) -> bool { ) -> bool {
match (&from_ty.kind(), &to_ty.kind()) { match (&from_ty.kind(), &to_ty.kind()) {
(ty::Int(_) | ty::Uint(_) | ty::Float(_), ty::Array(arr_ty, _)) => { (ty::Int(_) | ty::Uint(_) | ty::Float(_), ty::Array(arr_ty, _)) => {
if !matches!(arr_ty.kind(), ty::Uint(UintTy::U8)) { if !matches!(arr_ty.kind(), ty::Uint(UintTy::U8)) {
return false; return false;
} }
if matches!(from_ty.kind(), ty::Float(_)) && const_context {
// TODO: Remove when const_float_bits_conv is stabilized
// rust#72447
return false;
}
span_lint_and_then( span_lint_and_then(
cx, cx,

12
src/tools/clippy/tests/ui/transmute.rs
View File

@ -140,24 +140,32 @@ fn test() {
mod issue_5747 { mod issue_5747 {
const VALUE16: f16 = unsafe { std::mem::transmute(0_u16) }; const VALUE16: f16 = unsafe { std::mem::transmute(0_u16) };
//~^ ERROR: transmute from a `u16` to a `f16`
const VALUE32: f32 = unsafe { std::mem::transmute(0_u32) }; const VALUE32: f32 = unsafe { std::mem::transmute(0_u32) };
//~^ ERROR: transmute from a `u32` to a `f32`
const VALUE64: f64 = unsafe { std::mem::transmute(0_i64) }; const VALUE64: f64 = unsafe { std::mem::transmute(0_i64) };
//~^ ERROR: transmute from a `i64` to a `f64`
const VALUE128: f128 = unsafe { std::mem::transmute(0_i128) }; const VALUE128: f128 = unsafe { std::mem::transmute(0_i128) };
//~^ ERROR: transmute from a `i128` to a `f128`
const fn from_bits_16(v: i16) -> f16 { const fn from_bits_16(v: i16) -> f16 {
unsafe { std::mem::transmute(v) } unsafe { std::mem::transmute(v) }
//~^ ERROR: transmute from a `i16` to a `f16`
} }
const fn from_bits_32(v: i32) -> f32 { const fn from_bits_32(v: i32) -> f32 {
unsafe { std::mem::transmute(v) } unsafe { std::mem::transmute(v) }
//~^ ERROR: transmute from a `i32` to a `f32`
} }
const fn from_bits_64(v: u64) -> f64 { const fn from_bits_64(v: u64) -> f64 {
unsafe { std::mem::transmute(v) } unsafe { std::mem::transmute(v) }
//~^ ERROR: transmute from a `u64` to a `f64`
} }
const fn from_bits_128(v: u128) -> f128 { const fn from_bits_128(v: u128) -> f128 {
unsafe { std::mem::transmute(v) } unsafe { std::mem::transmute(v) }
//~^ ERROR: transmute from a `u128` to a `f128`
} }
} }
} }
@ -205,9 +213,13 @@ const fn test_const() {
//~^ ERROR: transmute from a `i128` to a `[u8; 16]` //~^ ERROR: transmute from a `i128` to a `[u8; 16]`
let _: [u8; 2] = std::mem::transmute(0.0f16); let _: [u8; 2] = std::mem::transmute(0.0f16);
//~^ ERROR: transmute from a `f16` to a `[u8; 2]`
let _: [u8; 4] = std::mem::transmute(0.0f32); let _: [u8; 4] = std::mem::transmute(0.0f32);
//~^ ERROR: transmute from a `f32` to a `[u8; 4]`
let _: [u8; 8] = std::mem::transmute(0.0f64); let _: [u8; 8] = std::mem::transmute(0.0f64);
//~^ ERROR: transmute from a `f64` to a `[u8; 8]`
let _: [u8; 16] = std::mem::transmute(0.0f128); let _: [u8; 16] = std::mem::transmute(0.0f128);
//~^ ERROR: transmute from a `f128` to a `[u8; 16]`
} }
} }
} }

112
src/tools/clippy/tests/ui/transmute.stderr
View File

@ -148,8 +148,56 @@ error: transmute from a `i128` to a `f128`
LL | let _: f128 = unsafe { std::mem::transmute(0_i128) }; LL | let _: f128 = unsafe { std::mem::transmute(0_i128) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f128::from_bits(0_i128 as u128)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f128::from_bits(0_i128 as u128)`
error: transmute from a `u16` to a `f16`
--> tests/ui/transmute.rs:142:39
|
LL | const VALUE16: f16 = unsafe { std::mem::transmute(0_u16) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f16::from_bits(0_u16)`
error: transmute from a `u32` to a `f32`
--> tests/ui/transmute.rs:144:39
|
LL | const VALUE32: f32 = unsafe { std::mem::transmute(0_u32) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f32::from_bits(0_u32)`
error: transmute from a `i64` to a `f64`
--> tests/ui/transmute.rs:146:39
|
LL | const VALUE64: f64 = unsafe { std::mem::transmute(0_i64) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f64::from_bits(0_i64 as u64)`
error: transmute from a `i128` to a `f128`
--> tests/ui/transmute.rs:148:41
|
LL | const VALUE128: f128 = unsafe { std::mem::transmute(0_i128) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f128::from_bits(0_i128 as u128)`
error: transmute from a `i16` to a `f16`
--> tests/ui/transmute.rs:152:22
|
LL | unsafe { std::mem::transmute(v) }
| ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f16::from_bits(v as u16)`
error: transmute from a `i32` to a `f32`
--> tests/ui/transmute.rs:157:22
|
LL | unsafe { std::mem::transmute(v) }
| ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f32::from_bits(v as u32)`
error: transmute from a `u64` to a `f64`
--> tests/ui/transmute.rs:162:22
|
LL | unsafe { std::mem::transmute(v) }
| ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f64::from_bits(v)`
error: transmute from a `u128` to a `f128`
--> tests/ui/transmute.rs:167:22
|
LL | unsafe { std::mem::transmute(v) }
| ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f128::from_bits(v)`
error: transmute from a `u8` to a `[u8; 1]` error: transmute from a `u8` to a `[u8; 1]`
--> tests/ui/transmute.rs:168:30 --> tests/ui/transmute.rs:176:30
| |
LL | let _: [u8; 1] = std::mem::transmute(0u8); LL | let _: [u8; 1] = std::mem::transmute(0u8);
| ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u8.to_ne_bytes()` | ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u8.to_ne_bytes()`
@ -158,97 +206,121 @@ LL | let _: [u8; 1] = std::mem::transmute(0u8);
= help: to override `-D warnings` add `#[allow(clippy::transmute_num_to_bytes)]` = help: to override `-D warnings` add `#[allow(clippy::transmute_num_to_bytes)]`
error: transmute from a `u32` to a `[u8; 4]` error: transmute from a `u32` to a `[u8; 4]`
--> tests/ui/transmute.rs:171:30 --> tests/ui/transmute.rs:179:30
| |
LL | let _: [u8; 4] = std::mem::transmute(0u32); LL | let _: [u8; 4] = std::mem::transmute(0u32);
| ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u32.to_ne_bytes()` | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u32.to_ne_bytes()`
error: transmute from a `u128` to a `[u8; 16]` error: transmute from a `u128` to a `[u8; 16]`
--> tests/ui/transmute.rs:173:31 --> tests/ui/transmute.rs:181:31
| |
LL | let _: [u8; 16] = std::mem::transmute(0u128); LL | let _: [u8; 16] = std::mem::transmute(0u128);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u128.to_ne_bytes()` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u128.to_ne_bytes()`
error: transmute from a `i8` to a `[u8; 1]` error: transmute from a `i8` to a `[u8; 1]`
--> tests/ui/transmute.rs:175:30 --> tests/ui/transmute.rs:183:30
| |
LL | let _: [u8; 1] = std::mem::transmute(0i8); LL | let _: [u8; 1] = std::mem::transmute(0i8);
| ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i8.to_ne_bytes()` | ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i8.to_ne_bytes()`
error: transmute from a `i32` to a `[u8; 4]` error: transmute from a `i32` to a `[u8; 4]`
--> tests/ui/transmute.rs:177:30 --> tests/ui/transmute.rs:185:30
| |
LL | let _: [u8; 4] = std::mem::transmute(0i32); LL | let _: [u8; 4] = std::mem::transmute(0i32);
| ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i32.to_ne_bytes()` | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i32.to_ne_bytes()`
error: transmute from a `i128` to a `[u8; 16]` error: transmute from a `i128` to a `[u8; 16]`
--> tests/ui/transmute.rs:179:31 --> tests/ui/transmute.rs:187:31
| |
LL | let _: [u8; 16] = std::mem::transmute(0i128); LL | let _: [u8; 16] = std::mem::transmute(0i128);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i128.to_ne_bytes()` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i128.to_ne_bytes()`
error: transmute from a `f16` to a `[u8; 2]` error: transmute from a `f16` to a `[u8; 2]`
--> tests/ui/transmute.rs:182:30 --> tests/ui/transmute.rs:190:30
| |
LL | let _: [u8; 2] = std::mem::transmute(0.0f16); LL | let _: [u8; 2] = std::mem::transmute(0.0f16);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f16.to_ne_bytes()` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f16.to_ne_bytes()`
error: transmute from a `f32` to a `[u8; 4]` error: transmute from a `f32` to a `[u8; 4]`
--> tests/ui/transmute.rs:184:30 --> tests/ui/transmute.rs:192:30
| |
LL | let _: [u8; 4] = std::mem::transmute(0.0f32); LL | let _: [u8; 4] = std::mem::transmute(0.0f32);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f32.to_ne_bytes()` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f32.to_ne_bytes()`
error: transmute from a `f64` to a `[u8; 8]` error: transmute from a `f64` to a `[u8; 8]`
--> tests/ui/transmute.rs:186:30 --> tests/ui/transmute.rs:194:30
| |
LL | let _: [u8; 8] = std::mem::transmute(0.0f64); LL | let _: [u8; 8] = std::mem::transmute(0.0f64);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f64.to_ne_bytes()` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f64.to_ne_bytes()`
error: transmute from a `f128` to a `[u8; 16]` error: transmute from a `f128` to a `[u8; 16]`
--> tests/ui/transmute.rs:188:31 --> tests/ui/transmute.rs:196:31
| |
LL | let _: [u8; 16] = std::mem::transmute(0.0f128); LL | let _: [u8; 16] = std::mem::transmute(0.0f128);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f128.to_ne_bytes()` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f128.to_ne_bytes()`
error: transmute from a `u8` to a `[u8; 1]` error: transmute from a `u8` to a `[u8; 1]`
--> tests/ui/transmute.rs:194:30 --> tests/ui/transmute.rs:202:30
| |
LL | let _: [u8; 1] = std::mem::transmute(0u8); LL | let _: [u8; 1] = std::mem::transmute(0u8);
| ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u8.to_ne_bytes()` | ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u8.to_ne_bytes()`
error: transmute from a `u32` to a `[u8; 4]` error: transmute from a `u32` to a `[u8; 4]`
--> tests/ui/transmute.rs:196:30 --> tests/ui/transmute.rs:204:30
| |
LL | let _: [u8; 4] = std::mem::transmute(0u32); LL | let _: [u8; 4] = std::mem::transmute(0u32);
| ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u32.to_ne_bytes()` | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u32.to_ne_bytes()`
error: transmute from a `u128` to a `[u8; 16]` error: transmute from a `u128` to a `[u8; 16]`
--> tests/ui/transmute.rs:198:31 --> tests/ui/transmute.rs:206:31
| |
LL | let _: [u8; 16] = std::mem::transmute(0u128); LL | let _: [u8; 16] = std::mem::transmute(0u128);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u128.to_ne_bytes()` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u128.to_ne_bytes()`
error: transmute from a `i8` to a `[u8; 1]` error: transmute from a `i8` to a `[u8; 1]`
--> tests/ui/transmute.rs:200:30 --> tests/ui/transmute.rs:208:30
| |
LL | let _: [u8; 1] = std::mem::transmute(0i8); LL | let _: [u8; 1] = std::mem::transmute(0i8);
| ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i8.to_ne_bytes()` | ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i8.to_ne_bytes()`
error: transmute from a `i32` to a `[u8; 4]` error: transmute from a `i32` to a `[u8; 4]`
--> tests/ui/transmute.rs:202:30 --> tests/ui/transmute.rs:210:30
| |
LL | let _: [u8; 4] = std::mem::transmute(0i32); LL | let _: [u8; 4] = std::mem::transmute(0i32);
| ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i32.to_ne_bytes()` | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i32.to_ne_bytes()`
error: transmute from a `i128` to a `[u8; 16]` error: transmute from a `i128` to a `[u8; 16]`
--> tests/ui/transmute.rs:204:31 --> tests/ui/transmute.rs:212:31
| |
LL | let _: [u8; 16] = std::mem::transmute(0i128); LL | let _: [u8; 16] = std::mem::transmute(0i128);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i128.to_ne_bytes()` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i128.to_ne_bytes()`
error: transmute from a `f16` to a `[u8; 2]`
--> tests/ui/transmute.rs:215:30
|
LL | let _: [u8; 2] = std::mem::transmute(0.0f16);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f16.to_ne_bytes()`
error: transmute from a `f32` to a `[u8; 4]`
--> tests/ui/transmute.rs:217:30
|
LL | let _: [u8; 4] = std::mem::transmute(0.0f32);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f32.to_ne_bytes()`
error: transmute from a `f64` to a `[u8; 8]`
--> tests/ui/transmute.rs:219:30
|
LL | let _: [u8; 8] = std::mem::transmute(0.0f64);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f64.to_ne_bytes()`
error: transmute from a `f128` to a `[u8; 16]`
--> tests/ui/transmute.rs:221:31
|
LL | let _: [u8; 16] = std::mem::transmute(0.0f128);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f128.to_ne_bytes()`
error: transmute from a `&[u8]` to a `&str` error: transmute from a `&[u8]` to a `&str`
--> tests/ui/transmute.rs:218:28 --> tests/ui/transmute.rs:230:28
| |
LL | let _: &str = unsafe { std::mem::transmute(B) }; LL | let _: &str = unsafe { std::mem::transmute(B) };
| ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8(B).unwrap()` | ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8(B).unwrap()`
@ -257,16 +329,16 @@ LL | let _: &str = unsafe { std::mem::transmute(B) };
= help: to override `-D warnings` add `#[allow(clippy::transmute_bytes_to_str)]` = help: to override `-D warnings` add `#[allow(clippy::transmute_bytes_to_str)]`
error: transmute from a `&mut [u8]` to a `&mut str` error: transmute from a `&mut [u8]` to a `&mut str`
--> tests/ui/transmute.rs:221:32 --> tests/ui/transmute.rs:233:32
| |
LL | let _: &mut str = unsafe { std::mem::transmute(mb) }; LL | let _: &mut str = unsafe { std::mem::transmute(mb) };
| ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8_mut(mb).unwrap()` | ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8_mut(mb).unwrap()`
error: transmute from a `&[u8]` to a `&str` error: transmute from a `&[u8]` to a `&str`
--> tests/ui/transmute.rs:223:30 --> tests/ui/transmute.rs:235:30
| |
LL | const _: &str = unsafe { std::mem::transmute(B) }; LL | const _: &str = unsafe { std::mem::transmute(B) };
| ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8_unchecked(B)` | ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8_unchecked(B)`
error: aborting due to 42 previous errors error: aborting due to 54 previous errors

28
src/tools/clippy/tests/ui/transmute_float_to_int.fixed
View File

@ -1,7 +1,7 @@
#![warn(clippy::transmute_float_to_int)] #![warn(clippy::transmute_float_to_int)]
#![allow(clippy::missing_transmute_annotations)] #![allow(clippy::missing_transmute_annotations)]
#![feature(f128)] #![feature(f128, f128_const)]
#![feature(f16)] #![feature(f16, f16_const)]
fn float_to_int() { fn float_to_int() {
let _: u32 = unsafe { 1f32.to_bits() }; let _: u32 = unsafe { 1f32.to_bits() };
@ -20,25 +20,33 @@ fn float_to_int() {
} }
mod issue_5747 { mod issue_5747 {
const VALUE16: i16 = unsafe { std::mem::transmute(1f16) }; const VALUE16: i16 = unsafe { 1f16.to_bits() as i16 };
const VALUE32: i32 = unsafe { std::mem::transmute(1f32) }; //~^ ERROR: transmute from a `f16` to a `i16`
const VALUE64: u64 = unsafe { std::mem::transmute(1f64) }; const VALUE32: i32 = unsafe { 1f32.to_bits() as i32 };
const VALUE128: u128 = unsafe { std::mem::transmute(1f128) }; //~^ ERROR: transmute from a `f32` to a `i32`
const VALUE64: u64 = unsafe { 1f64.to_bits() };
//~^ ERROR: transmute from a `f64` to a `u64`
const VALUE128: u128 = unsafe { 1f128.to_bits() };
//~^ ERROR: transmute from a `f128` to a `u128`
const fn to_bits_16(v: f16) -> u16 { const fn to_bits_16(v: f16) -> u16 {
unsafe { std::mem::transmute(v) } unsafe { v.to_bits() }
//~^ ERROR: transmute from a `f16` to a `u16`
} }
const fn to_bits_32(v: f32) -> u32 { const fn to_bits_32(v: f32) -> u32 {
unsafe { std::mem::transmute(v) } unsafe { v.to_bits() }
//~^ ERROR: transmute from a `f32` to a `u32`
} }
const fn to_bits_64(v: f64) -> i64 { const fn to_bits_64(v: f64) -> i64 {
unsafe { std::mem::transmute(v) } unsafe { v.to_bits() as i64 }
//~^ ERROR: transmute from a `f64` to a `i64`
} }
const fn to_bits_128(v: f128) -> i128 { const fn to_bits_128(v: f128) -> i128 {
unsafe { std::mem::transmute(v) } unsafe { v.to_bits() as i128 }
//~^ ERROR: transmute from a `f128` to a `i128`
} }
} }

12
src/tools/clippy/tests/ui/transmute_float_to_int.rs
View File

@ -1,7 +1,7 @@
#![warn(clippy::transmute_float_to_int)] #![warn(clippy::transmute_float_to_int)]
#![allow(clippy::missing_transmute_annotations)] #![allow(clippy::missing_transmute_annotations)]
#![feature(f128)] #![feature(f128, f128_const)]
#![feature(f16)] #![feature(f16, f16_const)]
fn float_to_int() { fn float_to_int() {
let _: u32 = unsafe { std::mem::transmute(1f32) }; let _: u32 = unsafe { std::mem::transmute(1f32) };
@ -21,24 +21,32 @@ fn float_to_int() {
mod issue_5747 { mod issue_5747 {
const VALUE16: i16 = unsafe { std::mem::transmute(1f16) }; const VALUE16: i16 = unsafe { std::mem::transmute(1f16) };
//~^ ERROR: transmute from a `f16` to a `i16`
const VALUE32: i32 = unsafe { std::mem::transmute(1f32) }; const VALUE32: i32 = unsafe { std::mem::transmute(1f32) };
//~^ ERROR: transmute from a `f32` to a `i32`
const VALUE64: u64 = unsafe { std::mem::transmute(1f64) }; const VALUE64: u64 = unsafe { std::mem::transmute(1f64) };
//~^ ERROR: transmute from a `f64` to a `u64`
const VALUE128: u128 = unsafe { std::mem::transmute(1f128) }; const VALUE128: u128 = unsafe { std::mem::transmute(1f128) };
//~^ ERROR: transmute from a `f128` to a `u128`
const fn to_bits_16(v: f16) -> u16 { const fn to_bits_16(v: f16) -> u16 {
unsafe { std::mem::transmute(v) } unsafe { std::mem::transmute(v) }
//~^ ERROR: transmute from a `f16` to a `u16`
} }
const fn to_bits_32(v: f32) -> u32 { const fn to_bits_32(v: f32) -> u32 {
unsafe { std::mem::transmute(v) } unsafe { std::mem::transmute(v) }
//~^ ERROR: transmute from a `f32` to a `u32`
} }
const fn to_bits_64(v: f64) -> i64 { const fn to_bits_64(v: f64) -> i64 {
unsafe { std::mem::transmute(v) } unsafe { std::mem::transmute(v) }
//~^ ERROR: transmute from a `f64` to a `i64`
} }
const fn to_bits_128(v: f128) -> i128 { const fn to_bits_128(v: f128) -> i128 {
unsafe { std::mem::transmute(v) } unsafe { std::mem::transmute(v) }
//~^ ERROR: transmute from a `f128` to a `i128`
} }
} }

50
src/tools/clippy/tests/ui/transmute_float_to_int.stderr
View File

@ -37,5 +37,53 @@ error: transmute from a `f64` to a `u64`
LL | let _: u64 = unsafe { std::mem::transmute(-1.0) }; LL | let _: u64 = unsafe { std::mem::transmute(-1.0) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(-1.0f64).to_bits()` | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(-1.0f64).to_bits()`
error: aborting due to 6 previous errors error: transmute from a `f16` to a `i16`
--> tests/ui/transmute_float_to_int.rs:23:35
|
LL | const VALUE16: i16 = unsafe { std::mem::transmute(1f16) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1f16.to_bits() as i16`
error: transmute from a `f32` to a `i32`
--> tests/ui/transmute_float_to_int.rs:25:35
|
LL | const VALUE32: i32 = unsafe { std::mem::transmute(1f32) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1f32.to_bits() as i32`
error: transmute from a `f64` to a `u64`
--> tests/ui/transmute_float_to_int.rs:27:35
|
LL | const VALUE64: u64 = unsafe { std::mem::transmute(1f64) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1f64.to_bits()`
error: transmute from a `f128` to a `u128`
--> tests/ui/transmute_float_to_int.rs:29:37
|
LL | const VALUE128: u128 = unsafe { std::mem::transmute(1f128) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1f128.to_bits()`
error: transmute from a `f16` to a `u16`
--> tests/ui/transmute_float_to_int.rs:33:18
|
LL | unsafe { std::mem::transmute(v) }
| ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `v.to_bits()`
error: transmute from a `f32` to a `u32`
--> tests/ui/transmute_float_to_int.rs:38:18
|
LL | unsafe { std::mem::transmute(v) }
| ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `v.to_bits()`
error: transmute from a `f64` to a `i64`
--> tests/ui/transmute_float_to_int.rs:43:18
|
LL | unsafe { std::mem::transmute(v) }
| ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `v.to_bits() as i64`
error: transmute from a `f128` to a `i128`
--> tests/ui/transmute_float_to_int.rs:48:18
|
LL | unsafe { std::mem::transmute(v) }
| ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `v.to_bits() as i128`
error: aborting due to 14 previous errors

5
tests/ui/consts/const-float-bits-conv.rs
View File

@ -1,10 +1,9 @@
//@ compile-flags: -Zmir-opt-level=0 //@ compile-flags: -Zmir-opt-level=0
//@ run-pass //@ run-pass
#![feature(const_float_bits_conv)]
#![feature(const_float_classify)] #![feature(const_float_classify)]
#![feature(f16)] #![feature(f16, f16_const)]
#![feature(f128)] #![feature(f128, f128_const)]
#![allow(unused_macro_rules)] #![allow(unused_macro_rules)]
// Don't promote // Don't promote
const fn nop<T>(x: T) -> T { x } const fn nop<T>(x: T) -> T { x }

1
tests/ui/consts/const-float-classify.rs
View File

@ -2,7 +2,6 @@
//@ known-bug: #110395 //@ known-bug: #110395
// FIXME(effects) run-pass // FIXME(effects) run-pass
#![feature(const_float_bits_conv)]
#![feature(const_float_classify)] #![feature(const_float_classify)]
#![feature(const_trait_impl, effects)] #![feature(const_trait_impl, effects)]
#![allow(incomplete_features)] #![allow(incomplete_features)]

2
tests/ui/consts/const-float-classify.stderr
View File

@ -1,5 +1,5 @@
error: const `impl` for trait `PartialEq` which is not marked with `#[const_trait]` error: const `impl` for trait `PartialEq` which is not marked with `#[const_trait]`
--> $DIR/const-float-classify.rs:13:12 --> $DIR/const-float-classify.rs:12:12
| |
LL | impl const PartialEq<NonDet> for bool { LL | impl const PartialEq<NonDet> for bool {
| ^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^