mathieu/os-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

safe transmute: Rename BikeshedIntrinsicFrom to TransmuteFrom

Browse source 
As our implementation of MCP411 nears completion and we begin to
solicit testing, it's no longer reasonable to expect testers to
type or remember `BikeshedIntrinsicFrom`. The name degrades the
ease-of-reading of documentation, and the overall experience of
using compiler safe transmute.

Tentatively, we'll instead adopt `TransmuteFrom`.

This name seems to be the one most likely to be stabilized, after
discussion on Zulip [1]. We may want to revisit the ordering of
`Src` and `Dst` before stabilization, at which point we'd likely
consider `TransmuteInto` or `Transmute`.

[1] https://rust-lang.zulipchat.com/#narrow/stream/216762-project-safe-transmute/topic/What.20should.20.60BikeshedIntrinsicFrom.60.20be.20named.3F
This commit is contained in:
Jack Wrenn 2024-08-27 14:05:54 +00:00
parent ae9f5019f9
commit 1ad218f3af
112 changed files with 528 additions and 531 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
View file

@ -862,7 +862,7 @@ where
_ecx: &mut EvalCtxt<'_, D>, _ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>, goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution> { ) -> Result<Candidate<I>, NoSolution> {
panic!("`BikeshedIntrinsicFrom` does not have an associated type: {:?}", goal) panic!("`TransmuteFrom` does not have an associated type: {:?}", goal)
} }
fn consider_builtin_effects_intersection_candidate( fn consider_builtin_effects_intersection_candidate(

2
library/core/src/mem/mod.rs
View file

@ -19,7 +19,7 @@ pub use maybe_uninit::MaybeUninit;
mod transmutability; mod transmutability;
#[unstable(feature = "transmutability", issue = "99571")] #[unstable(feature = "transmutability", issue = "99571")]
pub use transmutability::{Assume, BikeshedIntrinsicFrom}; pub use transmutability::{Assume, TransmuteFrom};
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[doc(inline)] #[doc(inline)]

109
library/core/src/mem/transmutability.rs
View file

@ -11,10 +11,10 @@ use crate::marker::{ConstParamTy_, UnsizedConstParamTy};
/// ///
/// # Safety /// # Safety
/// ///
/// If `Dst: BikeshedIntrinsicFrom<Src, ASSUMPTIONS>`, the compiler guarantees /// If `Dst: TransmuteFrom<Src, ASSUMPTIONS>`, the compiler guarantees that
/// that `Src` is soundly *union-transmutable* into a value of type `Dst`, /// `Src` is soundly *union-transmutable* into a value of type `Dst`, provided
/// provided that the programmer has guaranteed that the given /// that the programmer has guaranteed that the given [`ASSUMPTIONS`](Assume)
/// [`ASSUMPTIONS`](Assume) are satisfied. /// are satisfied.
/// ///
/// A union-transmute is any bit-reinterpretation conversion in the form of: /// A union-transmute is any bit-reinterpretation conversion in the form of:
/// ///
@ -47,7 +47,7 @@ use crate::marker::{ConstParamTy_, UnsizedConstParamTy};
#[cfg_attr(not(bootstrap), doc = "```rust")] #[cfg_attr(not(bootstrap), doc = "```rust")]
/// #![feature(transmutability)] /// #![feature(transmutability)]
/// ///
/// use core::mem::{Assume, BikeshedIntrinsicFrom}; /// use core::mem::{Assume, TransmuteFrom};
/// ///
/// let src = 42u8; // size = 1 /// let src = 42u8; // size = 1
/// ///
@ -55,7 +55,7 @@ use crate::marker::{ConstParamTy_, UnsizedConstParamTy};
/// struct Dst(u8); // size = 2 /// struct Dst(u8); // size = 2
// //
/// let _ = unsafe { /// let _ = unsafe {
/// <Dst as BikeshedIntrinsicFrom<u8, { Assume::SAFETY }>>::transmute(src) /// <Dst as TransmuteFrom<u8, { Assume::SAFETY }>>::transmute(src)
/// }; /// };
/// ``` /// ```
/// ///
@ -87,7 +87,7 @@ use crate::marker::{ConstParamTy_, UnsizedConstParamTy};
#[lang = "transmute_trait"] #[lang = "transmute_trait"]
#[rustc_deny_explicit_impl(implement_via_object = false)] #[rustc_deny_explicit_impl(implement_via_object = false)]
#[rustc_coinductive] #[rustc_coinductive]
pub unsafe trait BikeshedIntrinsicFrom<Src, const ASSUME: Assume = { Assume::NOTHING }> pub unsafe trait TransmuteFrom<Src, const ASSUME: Assume = { Assume::NOTHING }>
where where
Src: ?Sized, Src: ?Sized,
{ {
@ -140,23 +140,21 @@ where
} }
} }
/// Configurable proof assumptions of [`BikeshedIntrinsicFrom`]. /// Configurable proof assumptions of [`TransmuteFrom`].
/// ///
/// When `false`, the respective proof obligation belongs to the compiler. When /// When `false`, the respective proof obligation belongs to the compiler. When
/// `true`, the onus of the safety proof belongs to the programmer. /// `true`, the onus of the safety proof belongs to the programmer.
/// [`BikeshedIntrinsicFrom`].
#[unstable(feature = "transmutability", issue = "99571")] #[unstable(feature = "transmutability", issue = "99571")]
#[lang = "transmute_opts"] #[lang = "transmute_opts"]
#[derive(PartialEq, Eq, Clone, Copy, Debug)] #[derive(PartialEq, Eq, Clone, Copy, Debug)]
pub struct Assume { pub struct Assume {
/// When `false`, [`BikeshedIntrinsicFrom`] is not implemented for /// When `false`, [`TransmuteFrom`] is not implemented for transmutations
/// transmutations that might violate the the alignment requirements of /// that might violate the the alignment requirements of references; e.g.:
/// references; e.g.:
/// ///
#[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")] #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
#[cfg_attr(not(bootstrap), doc = "```compile_fail,E0277")] #[cfg_attr(not(bootstrap), doc = "```compile_fail,E0277")]
/// #![feature(transmutability)] /// #![feature(transmutability)]
/// use core::mem::{align_of, BikeshedIntrinsicFrom}; /// use core::mem::{align_of, TransmuteFrom};
/// ///
/// assert_eq!(align_of::<[u8; 2]>(), 1); /// assert_eq!(align_of::<[u8; 2]>(), 1);
/// assert_eq!(align_of::<u16>(), 2); /// assert_eq!(align_of::<u16>(), 2);
@ -165,18 +163,18 @@ pub struct Assume {
/// ///
/// // SAFETY: No safety obligations. /// // SAFETY: No safety obligations.
/// let dst: &u16 = unsafe { /// let dst: &u16 = unsafe {
/// <_ as BikeshedIntrinsicFrom<_>>::transmute(src) /// <_ as TransmuteFrom<_>>::transmute(src)
/// }; /// };
/// ``` /// ```
/// ///
/// When `true`, [`BikeshedIntrinsicFrom`] assumes that *you* have ensured /// When `true`, [`TransmuteFrom`] assumes that *you* have ensured
/// that references in the transmuted value satisfy the alignment /// that references in the transmuted value satisfy the alignment
/// requirements of their referent types; e.g.: /// requirements of their referent types; e.g.:
/// ///
#[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")] #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
#[cfg_attr(not(bootstrap), doc = "```rust")] #[cfg_attr(not(bootstrap), doc = "```rust")]
/// #![feature(pointer_is_aligned_to, transmutability)] /// #![feature(pointer_is_aligned_to, transmutability)]
/// use core::mem::{align_of, Assume, BikeshedIntrinsicFrom}; /// use core::mem::{align_of, Assume, TransmuteFrom};
/// ///
/// let src: &[u8; 2] = &[0xFF, 0xFF]; /// let src: &[u8; 2] = &[0xFF, 0xFF];
/// ///
@ -184,7 +182,7 @@ pub struct Assume {
/// // SAFETY: We have checked above that the address of `src` satisfies the /// // SAFETY: We have checked above that the address of `src` satisfies the
/// // alignment requirements of `u16`. /// // alignment requirements of `u16`.
/// Some(unsafe { /// Some(unsafe {
/// <_ as BikeshedIntrinsicFrom<_, { Assume::ALIGNMENT }>>::transmute(src) /// <_ as TransmuteFrom<_, { Assume::ALIGNMENT }>>::transmute(src)
/// }) /// })
/// } else { /// } else {
/// None /// None
@ -194,21 +192,21 @@ pub struct Assume {
/// ``` /// ```
pub alignment: bool, pub alignment: bool,
/// When `false`, [`BikeshedIntrinsicFrom`] is not implemented for /// When `false`, [`TransmuteFrom`] is not implemented for transmutations
/// transmutations that extend the lifetimes of references. /// that extend the lifetimes of references.
/// ///
/// When `true`, [`BikeshedIntrinsicFrom`] assumes that *you* have ensured /// When `true`, [`TransmuteFrom`] assumes that *you* have ensured that
/// that references in the transmuted value do not outlive their referents. /// references in the transmuted value do not outlive their referents.
pub lifetimes: bool, pub lifetimes: bool,
/// When `false`, [`BikeshedIntrinsicFrom`] is not implemented for /// When `false`, [`TransmuteFrom`] is not implemented for transmutations
/// transmutations that might violate the library safety invariants of the /// that might violate the library safety invariants of the destination
/// destination type; e.g.: /// type; e.g.:
/// ///
#[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")] #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
#[cfg_attr(not(bootstrap), doc = "```compile_fail,E0277")] #[cfg_attr(not(bootstrap), doc = "```compile_fail,E0277")]
/// #![feature(transmutability)] /// #![feature(transmutability)]
/// use core::mem::BikeshedIntrinsicFrom; /// use core::mem::TransmuteFrom;
/// ///
/// let src: u8 = 3; /// let src: u8 = 3;
/// ///
@ -219,18 +217,18 @@ pub struct Assume {
/// ///
/// // SAFETY: No safety obligations. /// // SAFETY: No safety obligations.
/// let dst: EvenU8 = unsafe { /// let dst: EvenU8 = unsafe {
/// <_ as BikeshedIntrinsicFrom<_>>::transmute(src) /// <_ as TransmuteFrom<_>>::transmute(src)
/// }; /// };
/// ``` /// ```
/// ///
/// When `true`, [`BikeshedIntrinsicFrom`] assumes that *you* have ensured /// When `true`, [`TransmuteFrom`] assumes that *you* have ensured
/// that undefined behavior does not arise from using the transmuted value; /// that undefined behavior does not arise from using the transmuted value;
/// e.g.: /// e.g.:
/// ///
#[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")] #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
#[cfg_attr(not(bootstrap), doc = "```rust")] #[cfg_attr(not(bootstrap), doc = "```rust")]
/// #![feature(transmutability)] /// #![feature(transmutability)]
/// use core::mem::{Assume, BikeshedIntrinsicFrom}; /// use core::mem::{Assume, TransmuteFrom};
/// ///
/// let src: u8 = 42; /// let src: u8 = 42;
/// ///
@ -242,7 +240,7 @@ pub struct Assume {
/// let maybe_dst: Option<EvenU8> = if src % 2 == 0 { /// let maybe_dst: Option<EvenU8> = if src % 2 == 0 {
/// // SAFETY: We have checked above that the value of `src` is even. /// // SAFETY: We have checked above that the value of `src` is even.
/// Some(unsafe { /// Some(unsafe {
/// <_ as BikeshedIntrinsicFrom<_, { Assume::SAFETY }>>::transmute(src) /// <_ as TransmuteFrom<_, { Assume::SAFETY }>>::transmute(src)
/// }) /// })
/// } else { /// } else {
/// None /// None
@ -252,31 +250,31 @@ pub struct Assume {
/// ``` /// ```
pub safety: bool, pub safety: bool,
/// When `false`, [`BikeshedIntrinsicFrom`] is not implemented for /// When `false`, [`TransmuteFrom`] is not implemented for transmutations
/// transmutations that might violate the language-level bit-validity /// that might violate the language-level bit-validity invariant of the
/// invariant of the destination type; e.g.: /// destination type; e.g.:
/// ///
#[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")] #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
#[cfg_attr(not(bootstrap), doc = "```compile_fail,E0277")] #[cfg_attr(not(bootstrap), doc = "```compile_fail,E0277")]
/// #![feature(transmutability)] /// #![feature(transmutability)]
/// use core::mem::BikeshedIntrinsicFrom; /// use core::mem::TransmuteFrom;
/// ///
/// let src: u8 = 3; /// let src: u8 = 3;
/// ///
/// // SAFETY: No safety obligations. /// // SAFETY: No safety obligations.
/// let dst: bool = unsafe { /// let dst: bool = unsafe {
/// <_ as BikeshedIntrinsicFrom<_>>::transmute(src) /// <_ as TransmuteFrom<_>>::transmute(src)
/// }; /// };
/// ``` /// ```
/// ///
/// When `true`, [`BikeshedIntrinsicFrom`] assumes that *you* have ensured /// When `true`, [`TransmuteFrom`] assumes that *you* have ensured
/// that the value being transmuted is a bit-valid instance of the /// that the value being transmuted is a bit-valid instance of the
/// transmuted value; e.g.: /// transmuted value; e.g.:
/// ///
#[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")] #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
#[cfg_attr(not(bootstrap), doc = "```rust")] #[cfg_attr(not(bootstrap), doc = "```rust")]
/// #![feature(transmutability)] /// #![feature(transmutability)]
/// use core::mem::{Assume, BikeshedIntrinsicFrom}; /// use core::mem::{Assume, TransmuteFrom};
/// ///
/// let src: u8 = 1; /// let src: u8 = 1;
/// ///
@ -284,7 +282,7 @@ pub struct Assume {
/// // SAFETY: We have checked above that the value of `src` is a bit-valid /// // SAFETY: We have checked above that the value of `src` is a bit-valid
/// // instance of `bool`. /// // instance of `bool`.
/// Some(unsafe { /// Some(unsafe {
/// <_ as BikeshedIntrinsicFrom<_, { Assume::VALIDITY }>>::transmute(src) /// <_ as TransmuteFrom<_, { Assume::VALIDITY }>>::transmute(src)
/// }) /// })
/// } else { /// } else {
/// None /// None
@ -301,35 +299,34 @@ impl ConstParamTy_ for Assume {}
impl UnsizedConstParamTy for Assume {} impl UnsizedConstParamTy for Assume {}
impl Assume { impl Assume {
/// With this, [`BikeshedIntrinsicFrom`] does not assume you have ensured /// With this, [`TransmuteFrom`] does not assume you have ensured any safety
/// any safety obligations are met, and relies only upon its own analysis to /// obligations are met, and relies only upon its own analysis to (dis)prove
/// (dis)prove transmutability. /// transmutability.
#[unstable(feature = "transmutability", issue = "99571")] #[unstable(feature = "transmutability", issue = "99571")]
pub const NOTHING: Self = pub const NOTHING: Self =
Self { alignment: false, lifetimes: false, safety: false, validity: false }; Self { alignment: false, lifetimes: false, safety: false, validity: false };
/// With this, [`BikeshedIntrinsicFrom`] assumes only that you have ensured /// With this, [`TransmuteFrom`] assumes only that you have ensured that
/// that references in the transmuted value satisfy the alignment /// references in the transmuted value satisfy the alignment requirements of
/// requirements of their referent types. See [`Assume::alignment`] for /// their referent types. See [`Assume::alignment`] for examples.
/// examples.
#[unstable(feature = "transmutability", issue = "99571")] #[unstable(feature = "transmutability", issue = "99571")]
pub const ALIGNMENT: Self = Self { alignment: true, ..Self::NOTHING }; pub const ALIGNMENT: Self = Self { alignment: true, ..Self::NOTHING };
/// With this, [`BikeshedIntrinsicFrom`] assumes only that you have ensured /// With this, [`TransmuteFrom`] assumes only that you have ensured that
/// that references in the transmuted value do not outlive their referents. /// references in the transmuted value do not outlive their referents. See
/// See [`Assume::lifetimes`] for examples. /// [`Assume::lifetimes`] for examples.
#[unstable(feature = "transmutability", issue = "99571")] #[unstable(feature = "transmutability", issue = "99571")]
pub const LIFETIMES: Self = Self { lifetimes: true, ..Self::NOTHING }; pub const LIFETIMES: Self = Self { lifetimes: true, ..Self::NOTHING };
/// With this, [`BikeshedIntrinsicFrom`] assumes only that you have ensured /// With this, [`TransmuteFrom`] assumes only that you have ensured that
/// that undefined behavior does not arise from using the transmuted value. /// undefined behavior does not arise from using the transmuted value. See
/// See [`Assume::safety`] for examples. /// [`Assume::safety`] for examples.
#[unstable(feature = "transmutability", issue = "99571")] #[unstable(feature = "transmutability", issue = "99571")]
pub const SAFETY: Self = Self { safety: true, ..Self::NOTHING }; pub const SAFETY: Self = Self { safety: true, ..Self::NOTHING };
/// With this, [`BikeshedIntrinsicFrom`] assumes only that you have ensured /// With this, [`TransmuteFrom`] assumes only that you have ensured that the
/// that the value being transmuted is a bit-valid instance of the /// value being transmuted is a bit-valid instance of the transmuted value.
/// transmuted value. See [`Assume::validity`] for examples. /// See [`Assume::validity`] for examples.
#[unstable(feature = "transmutability", issue = "99571")] #[unstable(feature = "transmutability", issue = "99571")]
pub const VALIDITY: Self = Self { validity: true, ..Self::NOTHING }; pub const VALIDITY: Self = Self { validity: true, ..Self::NOTHING };
@ -348,7 +345,7 @@ impl Assume {
/// transmutability, /// transmutability,
/// )] /// )]
/// #![allow(incomplete_features)] /// #![allow(incomplete_features)]
/// use core::mem::{align_of, Assume, BikeshedIntrinsicFrom}; /// use core::mem::{align_of, Assume, TransmuteFrom};
/// ///
/// /// Attempts to transmute `src` to `&Dst`. /// /// Attempts to transmute `src` to `&Dst`.
/// /// /// ///
@ -360,7 +357,7 @@ impl Assume {
/// /// alignment, are satisfied. /// /// alignment, are satisfied.
/// unsafe fn try_transmute_ref<'a, Src, Dst, const ASSUME: Assume>(src: &'a Src) -> Option<&'a Dst> /// unsafe fn try_transmute_ref<'a, Src, Dst, const ASSUME: Assume>(src: &'a Src) -> Option<&'a Dst>
/// where /// where
/// &'a Dst: BikeshedIntrinsicFrom<&'a Src, { ASSUME.and(Assume::ALIGNMENT) }>, /// &'a Dst: TransmuteFrom<&'a Src, { ASSUME.and(Assume::ALIGNMENT) }>,
/// { /// {
/// if <*const _>::is_aligned_to(src, align_of::<Dst>()) { /// if <*const _>::is_aligned_to(src, align_of::<Dst>()) {
/// // SAFETY: By the above dynamic check, we have ensured that the address /// // SAFETY: By the above dynamic check, we have ensured that the address
@ -368,7 +365,7 @@ impl Assume {
/// // on the caller, the safety obligations required by `ASSUME` have also /// // on the caller, the safety obligations required by `ASSUME` have also
/// // been satisfied. /// // been satisfied.
/// Some(unsafe { /// Some(unsafe {
/// <_ as BikeshedIntrinsicFrom<_, { ASSUME.and(Assume::ALIGNMENT) }>>::transmute(src) /// <_ as TransmuteFrom<_, { ASSUME.and(Assume::ALIGNMENT) }>>::transmute(src)
/// }) /// })
/// } else { /// } else {
/// None /// None

4
tests/crashes/123693.rs
View file

@ -3,11 +3,11 @@
#![feature(transmutability)] #![feature(transmutability)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Assume::NOTHING }>, Dst: TransmuteFrom<Src, { Assume::NOTHING }>,
{ {
} }
} }

2
tests/crashes/124207.rs
View file

@ -4,6 +4,6 @@
trait OpaqueTrait {} trait OpaqueTrait {}
type OpaqueType = impl OpaqueTrait; type OpaqueType = impl OpaqueTrait;
trait AnotherTrait {} trait AnotherTrait {}
impl<T: std::mem::BikeshedIntrinsicFrom<(), ()>> AnotherTrait for T {} impl<T: std::mem::TransmuteFrom<(), ()>> AnotherTrait for T {}
impl AnotherTrait for OpaqueType {} impl AnotherTrait for OpaqueType {}
pub fn main() {} pub fn main() {}

2
tests/crashes/125881.rs
View file

@ -3,6 +3,6 @@
#![feature(transmutability)] #![feature(transmutability)]
#![feature(unboxed_closures,effects)] #![feature(unboxed_closures,effects)]
const fn test() -> impl std::mem::BikeshedIntrinsicFrom() { const fn test() -> impl std::mem::TransmuteFrom() {
|| {} || {}
} }

4
tests/crashes/126267.rs
View file

@ -14,11 +14,11 @@ pub enum Error {
} }
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::TransmuteFrom;
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src>, // safety is NOT assumed Dst: TransmuteFrom<Src>, // safety is NOT assumed
{ {
} }
} }

4
tests/crashes/126377.rs
View file

@ -4,7 +4,7 @@
#![feature(generic_const_exprs)] #![feature(generic_const_exprs)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable< pub fn is_transmutable<
Src, Src,
@ -15,7 +15,7 @@ mod assert {
const ASSUME_VALIDITY: bool, const ASSUME_VALIDITY: bool,
>() >()
where where
Dst: BikeshedIntrinsicFrom< Dst: TransmuteFrom<
Src, Src,
{ } { }
>, >,

4
tests/crashes/126966.rs
View file

@ -1,10 +1,10 @@
//@ known-bug: rust-lang/rust#126966 //@ known-bug: rust-lang/rust#126966
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src>, Dst: TransmuteFrom<Src>,
{ {
} }
} }

4
tests/ui/const-generics/adt_const_params/transmutable-ice-110969.rs
View file

@ -4,11 +4,11 @@
#![allow(incomplete_features, unstable_features)] #![allow(incomplete_features, unstable_features)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::TransmuteFrom;
pub fn is_transmutable<Src, Dst, Context, const ASSUME: std::mem::Assume>() pub fn is_transmutable<Src, Dst, Context, const ASSUME: std::mem::Assume>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, ASSUME>, Dst: TransmuteFrom<Src, Context, ASSUME>,
//~^ ERROR trait takes at most 2 generic arguments but 3 generic arguments were supplied //~^ ERROR trait takes at most 2 generic arguments but 3 generic arguments were supplied
{ {
} }

4
tests/ui/const-generics/adt_const_params/transmutable-ice-110969.stderr
View file

@ -1,8 +1,8 @@
error[E0107]: trait takes at most 2 generic arguments but 3 generic arguments were supplied error[E0107]: trait takes at most 2 generic arguments but 3 generic arguments were supplied
--> $DIR/transmutable-ice-110969.rs:11:14 --> $DIR/transmutable-ice-110969.rs:11:14
| |
LL | Dst: BikeshedIntrinsicFrom<Src, Context, ASSUME>, LL | Dst: TransmuteFrom<Src, Context, ASSUME>,
| ^^^^^^^^^^^^^^^^^^^^^ -------- help: remove the unnecessary generic argument | ^^^^^^^^^^^^^ -------- help: remove the unnecessary generic argument
| | | |
| expected at most 2 generic arguments | expected at most 2 generic arguments

4
tests/ui/transmutability/abstraction/abstracted_assume.rs
View file

@ -8,7 +8,7 @@
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::TransmuteFrom;
pub fn is_transmutable< pub fn is_transmutable<
Src, Src,
@ -16,7 +16,7 @@ mod assert {
const ASSUME: std::mem::Assume, const ASSUME: std::mem::Assume,
>() >()
where where
Dst: BikeshedIntrinsicFrom< Dst: TransmuteFrom<
Src, Src,
ASSUME, ASSUME,
>, >,

6
tests/ui/transmutability/abstraction/const_generic_fn.rs
View file

@ -6,12 +6,12 @@
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn array_like<T, E, const N: usize>() pub fn array_like<T, E, const N: usize>()
where where
T: BikeshedIntrinsicFrom<[E; N], { Assume::SAFETY }>, T: TransmuteFrom<[E; N], { Assume::SAFETY }>,
[E; N]: BikeshedIntrinsicFrom<T, { Assume::SAFETY }> [E; N]: TransmuteFrom<T, { Assume::SAFETY }>
{} {}
} }

4
tests/ui/transmutability/alignment/align-fail.rs
View file

@ -2,11 +2,11 @@
#![feature(transmutability)] #![feature(transmutability)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: false, alignment: false,
lifetimes: true, lifetimes: true,

2
tests/ui/transmutability/alignment/align-fail.stderr
View file

@ -10,7 +10,7 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: false, LL | | alignment: false,

4
tests/ui/transmutability/alignment/align-pass.rs
View file

@ -2,11 +2,11 @@
#![feature(transmutability)] #![feature(transmutability)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: false, alignment: false,
lifetimes: false, lifetimes: false,

4
tests/ui/transmutability/arrays/huge-len.rs
View file

@ -1,11 +1,11 @@
#![crate_type = "lib"] #![crate_type = "lib"]
#![feature(transmutability)] #![feature(transmutability)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::TransmuteFrom;
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src>, Dst: TransmuteFrom<Src>,
{ {
} }
} }

8
tests/ui/transmutability/arrays/huge-len.stderr
View file

@ -10,8 +10,8 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src>, LL | Dst: TransmuteFrom<Src>,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
error[E0277]: `ExplicitlyPadded` cannot be safely transmuted into `()` error[E0277]: `ExplicitlyPadded` cannot be safely transmuted into `()`
--> $DIR/huge-len.rs:24:55 --> $DIR/huge-len.rs:24:55
@ -25,8 +25,8 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src>, LL | Dst: TransmuteFrom<Src>,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
error: aborting due to 2 previous errors error: aborting due to 2 previous errors

4
tests/ui/transmutability/arrays/issue-103783-array-length.rs
View file

@ -3,11 +3,11 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom< Dst: TransmuteFrom<
Src, Src,
{ Assume { alignment: true, lifetimes: true, safety: true, validity: true } }, { Assume { alignment: true, lifetimes: true, safety: true, validity: true } },
>, >,

4
tests/ui/transmutability/arrays/should_have_correct_length.rs
View file

@ -6,11 +6,11 @@
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY.and(Assume::VALIDITY) }> Dst: TransmuteFrom<Src, { Assume::SAFETY.and(Assume::VALIDITY) }>
{} {}
} }

4
tests/ui/transmutability/arrays/should_inherit_alignment.rs
View file

@ -6,11 +6,11 @@
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume::ALIGNMENT Assume::ALIGNMENT
.and(Assume::LIFETIMES) .and(Assume::LIFETIMES)
.and(Assume::SAFETY) .and(Assume::SAFETY)

4
tests/ui/transmutability/arrays/should_require_well_defined_layout.rs
View file

@ -5,11 +5,11 @@
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume::ALIGNMENT Assume::ALIGNMENT
.and(Assume::LIFETIMES) .and(Assume::LIFETIMES)
.and(Assume::SAFETY) .and(Assume::SAFETY)

12
tests/ui/transmutability/arrays/should_require_well_defined_layout.stderr
View file

@ -10,7 +10,7 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume::ALIGNMENT LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES) LL | | .and(Assume::LIFETIMES)
@ -31,7 +31,7 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume::ALIGNMENT LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES) LL | | .and(Assume::LIFETIMES)
@ -52,7 +52,7 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume::ALIGNMENT LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES) LL | | .and(Assume::LIFETIMES)
@ -73,7 +73,7 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume::ALIGNMENT LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES) LL | | .and(Assume::LIFETIMES)
@ -94,7 +94,7 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume::ALIGNMENT LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES) LL | | .and(Assume::LIFETIMES)
@ -115,7 +115,7 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume::ALIGNMENT LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES) LL | | .and(Assume::LIFETIMES)

6
tests/ui/transmutability/enums/niche_optimization.rs
View file

@ -5,11 +5,11 @@
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: false, alignment: false,
lifetimes: false, lifetimes: false,
@ -21,7 +21,7 @@ mod assert {
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: false, alignment: false,
lifetimes: false, lifetimes: false,

6
tests/ui/transmutability/enums/repr/padding_differences.rs
View file

@ -7,11 +7,11 @@
use std::mem::MaybeUninit; use std::mem::MaybeUninit;
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: false, alignment: false,
lifetimes: false, lifetimes: false,
@ -23,7 +23,7 @@ mod assert {
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: false, alignment: false,
lifetimes: false, lifetimes: false,

4
tests/ui/transmutability/enums/repr/primitive_reprs_should_have_correct_length.rs
View file

@ -5,11 +5,11 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: true, alignment: true,
lifetimes: true, lifetimes: true,

40
tests/ui/transmutability/enums/repr/primitive_reprs_should_have_correct_length.stderr
View file

@ -10,7 +10,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -32,7 +32,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -54,7 +54,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -76,7 +76,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -98,7 +98,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -120,7 +120,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -142,7 +142,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -164,7 +164,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -186,7 +186,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -208,7 +208,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -230,7 +230,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -252,7 +252,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -274,7 +274,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -296,7 +296,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -318,7 +318,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -340,7 +340,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -362,7 +362,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -384,7 +384,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -406,7 +406,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -428,7 +428,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,

4
tests/ui/transmutability/enums/repr/should_handle_all.rs
View file

@ -5,11 +5,11 @@
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: true, alignment: true,
lifetimes: true, lifetimes: true,

4
tests/ui/transmutability/enums/should_order_correctly.rs
View file

@ -6,11 +6,11 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume::ALIGNMENT Assume::ALIGNMENT
.and(Assume::LIFETIMES) .and(Assume::LIFETIMES)
.and(Assume::SAFETY) .and(Assume::SAFETY)

4
tests/ui/transmutability/enums/should_pad_variants.rs
View file

@ -6,11 +6,11 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume::ALIGNMENT Assume::ALIGNMENT
.and(Assume::LIFETIMES) .and(Assume::LIFETIMES)
.and(Assume::SAFETY) .and(Assume::SAFETY)

2
tests/ui/transmutability/enums/should_pad_variants.stderr
View file

@ -10,7 +10,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume::ALIGNMENT LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES) LL | | .and(Assume::LIFETIMES)

4
tests/ui/transmutability/enums/should_respect_endianness.rs
View file

@ -6,11 +6,11 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume::ALIGNMENT Assume::ALIGNMENT
.and(Assume::LIFETIMES) .and(Assume::LIFETIMES)
.and(Assume::SAFETY) .and(Assume::SAFETY)

2
tests/ui/transmutability/enums/should_respect_endianness.stderr
View file

@ -10,7 +10,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume::ALIGNMENT LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES) LL | | .and(Assume::LIFETIMES)

2
tests/ui/transmutability/enums/uninhabited_optimization.rs
View file

@ -4,7 +4,7 @@
fn assert_transmutable<T>() fn assert_transmutable<T>()
where where
(): std::mem::BikeshedIntrinsicFrom<T> (): std::mem::TransmuteFrom<T>
{} {}
enum Uninhabited {} enum Uninhabited {}

4
tests/ui/transmutability/issue-101739-1.rs
View file

@ -1,11 +1,11 @@
#![feature(transmutability)] #![feature(transmutability)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::TransmuteFrom;
pub fn is_transmutable<Src, const ASSUME_ALIGNMENT: bool>() pub fn is_transmutable<Src, const ASSUME_ALIGNMENT: bool>()
where where
Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>, //~ ERROR cannot find type `Dst` in this scope Dst: TransmuteFrom<Src, ASSUME_ALIGNMENT>, //~ ERROR cannot find type `Dst` in this scope
//~| the constant `ASSUME_ALIGNMENT` is not of type `Assume` //~| the constant `ASSUME_ALIGNMENT` is not of type `Assume`
//~| ERROR: mismatched types //~| ERROR: mismatched types
{ {

14
tests/ui/transmutability/issue-101739-1.stderr
View file

@ -1,23 +1,23 @@
error[E0412]: cannot find type `Dst` in this scope error[E0412]: cannot find type `Dst` in this scope
--> $DIR/issue-101739-1.rs:8:9 --> $DIR/issue-101739-1.rs:8:9
| |
LL | Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>, LL | Dst: TransmuteFrom<Src, ASSUME_ALIGNMENT>,
| ^^^ not found in this scope | ^^^ not found in this scope
error: the constant `ASSUME_ALIGNMENT` is not of type `Assume` error: the constant `ASSUME_ALIGNMENT` is not of type `Assume`
--> $DIR/issue-101739-1.rs:8:14 --> $DIR/issue-101739-1.rs:8:14
| |
LL | Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>, LL | Dst: TransmuteFrom<Src, ASSUME_ALIGNMENT>,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Assume`, found `bool` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Assume`, found `bool`
| |
note: required by a const generic parameter in `BikeshedIntrinsicFrom` note: required by a const generic parameter in `TransmuteFrom`
--> $SRC_DIR/core/src/mem/transmutability.rs:LL:COL --> $SRC_DIR/core/src/mem/transmutability.rs:LL:COL
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/issue-101739-1.rs:8:41 --> $DIR/issue-101739-1.rs:8:33
| |
LL | Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>, LL | Dst: TransmuteFrom<Src, ASSUME_ALIGNMENT>,
| ^^^^^^^^^^^^^^^^ expected `Assume`, found `bool` | ^^^^^^^^^^^^^^^^ expected `Assume`, found `bool`
error: aborting due to 3 previous errors error: aborting due to 3 previous errors

4
tests/ui/transmutability/issue-101739-2.rs
View file

@ -3,7 +3,7 @@
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::TransmuteFrom;
pub fn is_transmutable< pub fn is_transmutable<
Src, Src,
@ -14,7 +14,7 @@ mod assert {
const ASSUME_VISIBILITY: bool, const ASSUME_VISIBILITY: bool,
>() >()
where where
Dst: BikeshedIntrinsicFrom< Dst: TransmuteFrom<
//~^ ERROR trait takes at most 2 generic arguments but 5 generic arguments were supplied //~^ ERROR trait takes at most 2 generic arguments but 5 generic arguments were supplied
Src, Src,
ASSUME_ALIGNMENT, //~ ERROR: mismatched types ASSUME_ALIGNMENT, //~ ERROR: mismatched types

4
tests/ui/transmutability/issue-101739-2.stderr
View file

@ -1,8 +1,8 @@
error[E0107]: trait takes at most 2 generic arguments but 5 generic arguments were supplied error[E0107]: trait takes at most 2 generic arguments but 5 generic arguments were supplied
--> $DIR/issue-101739-2.rs:17:14 --> $DIR/issue-101739-2.rs:17:14
| |
LL | Dst: BikeshedIntrinsicFrom< LL | Dst: TransmuteFrom<
| ^^^^^^^^^^^^^^^^^^^^^ expected at most 2 generic arguments | ^^^^^^^^^^^^^ expected at most 2 generic arguments
... ...
LL | ASSUME_ALIGNMENT, LL | ASSUME_ALIGNMENT,
| _________________________________- | _________________________________-

4
tests/ui/transmutability/issue-110467.rs
View file

@ -1,11 +1,11 @@
//@ check-pass //@ check-pass
#![crate_type = "lib"] #![crate_type = "lib"]
#![feature(transmutability)] #![feature(transmutability)]
use std::mem::BikeshedIntrinsicFrom; use std::mem::TransmuteFrom;
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src>, Dst: TransmuteFrom<Src>,
{ {
} }

4
tests/ui/transmutability/issue-110892.rs
View file

@ -3,7 +3,7 @@
#![allow(incomplete_features)] #![allow(incomplete_features)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable< pub fn is_transmutable<
Src, Src,
@ -14,7 +14,7 @@ mod assert {
const ASSUME_VALIDITY: bool, const ASSUME_VALIDITY: bool,
>() >()
where where
Dst: BikeshedIntrinsicFrom< Dst: TransmuteFrom<
Src, Src,
{ from_options(ASSUME_ALIGNMENT, ASSUME_LIFETIMES, ASSUME_SAFETY, ASSUME_VALIDITY) } { from_options(ASSUME_ALIGNMENT, ASSUME_LIFETIMES, ASSUME_SAFETY, ASSUME_VALIDITY) }
>, >,

2
tests/ui/transmutability/malformed-program-gracefulness/feature-missing.rs
View file

@ -2,7 +2,7 @@
#![crate_type = "lib"] #![crate_type = "lib"]
use std::mem::BikeshedIntrinsicFrom; use std::mem::TransmuteFrom;
//~^ ERROR use of unstable library feature 'transmutability' [E0658] //~^ ERROR use of unstable library feature 'transmutability' [E0658]
use std::mem::Assume; use std::mem::Assume;

4
tests/ui/transmutability/malformed-program-gracefulness/feature-missing.stderr
View file

@ -1,8 +1,8 @@
error[E0658]: use of unstable library feature 'transmutability' error[E0658]: use of unstable library feature 'transmutability'
--> $DIR/feature-missing.rs:5:5 --> $DIR/feature-missing.rs:5:5
| |
LL | use std::mem::BikeshedIntrinsicFrom; LL | use std::mem::TransmuteFrom;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: see issue #99571 <https://github.com/rust-lang/rust/issues/99571> for more information = note: see issue #99571 <https://github.com/rust-lang/rust/issues/99571> for more information
= help: add `#![feature(transmutability)]` to the crate attributes to enable = help: add `#![feature(transmutability)]` to the crate attributes to enable

4
tests/ui/transmutability/malformed-program-gracefulness/unknown_dst.rs
View file

@ -5,11 +5,11 @@
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::TransmuteFrom;
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src> Dst: TransmuteFrom<Src>
{} {}
} }

4
tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.rs
View file

@ -5,11 +5,11 @@
#![allow(incomplete_features)] #![allow(incomplete_features)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::TransmuteFrom;
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src> Dst: TransmuteFrom<Src>
{} {}
} }

8
tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.stderr
View file

@ -22,8 +22,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `should_gracefully_handle_unknown_dst_ref_field::Src` cannot be safely transmuted into `should_gracefully_handle_unknown_dst_ref_field::Dst` error[E0277]: `should_gracefully_handle_unknown_dst_ref_field::Src` cannot be safely transmuted into `should_gracefully_handle_unknown_dst_ref_field::Dst`
--> $DIR/unknown_dst_field.rs:25:36 --> $DIR/unknown_dst_field.rs:25:36
@ -37,8 +37,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error: aborting due to 4 previous errors error: aborting due to 4 previous errors

4
tests/ui/transmutability/malformed-program-gracefulness/unknown_src.rs
View file

@ -5,11 +5,11 @@
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::TransmuteFrom;
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src> Dst: TransmuteFrom<Src>
{} {}
} }

4
tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.rs
View file

@ -5,11 +5,11 @@
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::TransmuteFrom;
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src> Dst: TransmuteFrom<Src>
{} {}
} }

8
tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.stderr
View file

@ -22,8 +22,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `should_gracefully_handle_unknown_src_ref_field::Src` cannot be safely transmuted into `should_gracefully_handle_unknown_src_ref_field::Dst` error[E0277]: `should_gracefully_handle_unknown_src_ref_field::Src` cannot be safely transmuted into `should_gracefully_handle_unknown_src_ref_field::Dst`
--> $DIR/unknown_src_field.rs:25:36 --> $DIR/unknown_src_field.rs:25:36
@ -37,8 +37,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error: aborting due to 4 previous errors error: aborting due to 4 previous errors

4
tests/ui/transmutability/malformed-program-gracefulness/wrong-type-assume.rs
View file

@ -8,7 +8,7 @@
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable< pub fn is_transmutable<
Src, Src,
@ -19,7 +19,7 @@ mod assert {
const ASSUME_VALIDITY: bool, const ASSUME_VALIDITY: bool,
>() >()
where where
Dst: BikeshedIntrinsicFrom< Dst: TransmuteFrom<
Src, Src,
{ from_options(ASSUME_ALIGNMENT, ASSUME_LIFETIMES, ASSUME_SAFETY, ASSUME_VALIDITY) } { from_options(ASSUME_ALIGNMENT, ASSUME_LIFETIMES, ASSUME_SAFETY, ASSUME_VALIDITY) }
>, >,

4
tests/ui/transmutability/maybeuninit.rs
View file

@ -5,11 +5,11 @@
use std::mem::MaybeUninit; use std::mem::MaybeUninit;
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }> Dst: TransmuteFrom<Src, { Assume::SAFETY }>
{} {}
} }

4
tests/ui/transmutability/maybeuninit.stderr
View file

@ -10,8 +10,8 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }> LL | Dst: TransmuteFrom<Src, { Assume::SAFETY }>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
error: aborting due to 1 previous error error: aborting due to 1 previous error

4
tests/ui/transmutability/primitives/bool-mut.rs
View file

@ -2,11 +2,11 @@
#![feature(transmutability)] #![feature(transmutability)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }> Dst: TransmuteFrom<Src, { Assume::SAFETY }>
{} {}
} }

4
tests/ui/transmutability/primitives/bool-mut.stderr
View file

@ -10,8 +10,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }> LL | Dst: TransmuteFrom<Src, { Assume::SAFETY }>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error: aborting due to 1 previous error error: aborting due to 1 previous error

4
tests/ui/transmutability/primitives/bool.current.stderr
View file

@ -10,8 +10,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }> LL | Dst: TransmuteFrom<Src, { Assume::SAFETY }>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error: aborting due to 1 previous error error: aborting due to 1 previous error

4
tests/ui/transmutability/primitives/bool.next.stderr
View file

@ -10,8 +10,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }> LL | Dst: TransmuteFrom<Src, { Assume::SAFETY }>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error: aborting due to 1 previous error error: aborting due to 1 previous error

6
tests/ui/transmutability/primitives/bool.rs
View file

@ -4,16 +4,16 @@
#![feature(transmutability)] #![feature(transmutability)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }> Dst: TransmuteFrom<Src, { Assume::SAFETY }>
{} {}
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY.and(Assume::VALIDITY) }> Dst: TransmuteFrom<Src, { Assume::SAFETY.and(Assume::VALIDITY) }>
{} {}
} }

228
tests/ui/transmutability/primitives/numbers.current.stderr
View file

@ -10,8 +10,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `u16` error[E0277]: `i8` cannot be safely transmuted into `u16`
--> $DIR/numbers.rs:65:40 --> $DIR/numbers.rs:65:40
@ -25,8 +25,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `i32` error[E0277]: `i8` cannot be safely transmuted into `i32`
--> $DIR/numbers.rs:66:40 --> $DIR/numbers.rs:66:40
@ -40,8 +40,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `f32` error[E0277]: `i8` cannot be safely transmuted into `f32`
--> $DIR/numbers.rs:67:40 --> $DIR/numbers.rs:67:40
@ -55,8 +55,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `u32` error[E0277]: `i8` cannot be safely transmuted into `u32`
--> $DIR/numbers.rs:68:40 --> $DIR/numbers.rs:68:40
@ -70,8 +70,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `u64` error[E0277]: `i8` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:69:40 --> $DIR/numbers.rs:69:40
@ -85,8 +85,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `i64` error[E0277]: `i8` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:70:40 --> $DIR/numbers.rs:70:40
@ -100,8 +100,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `f64` error[E0277]: `i8` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:71:40 --> $DIR/numbers.rs:71:40
@ -115,8 +115,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `u128` error[E0277]: `i8` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:72:39 --> $DIR/numbers.rs:72:39
@ -130,8 +130,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `i128` error[E0277]: `i8` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:73:39 --> $DIR/numbers.rs:73:39
@ -145,8 +145,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `i16` error[E0277]: `u8` cannot be safely transmuted into `i16`
--> $DIR/numbers.rs:75:40 --> $DIR/numbers.rs:75:40
@ -160,8 +160,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `u16` error[E0277]: `u8` cannot be safely transmuted into `u16`
--> $DIR/numbers.rs:76:40 --> $DIR/numbers.rs:76:40
@ -175,8 +175,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `i32` error[E0277]: `u8` cannot be safely transmuted into `i32`
--> $DIR/numbers.rs:77:40 --> $DIR/numbers.rs:77:40
@ -190,8 +190,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `f32` error[E0277]: `u8` cannot be safely transmuted into `f32`
--> $DIR/numbers.rs:78:40 --> $DIR/numbers.rs:78:40
@ -205,8 +205,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `u32` error[E0277]: `u8` cannot be safely transmuted into `u32`
--> $DIR/numbers.rs:79:40 --> $DIR/numbers.rs:79:40
@ -220,8 +220,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `u64` error[E0277]: `u8` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:80:40 --> $DIR/numbers.rs:80:40
@ -235,8 +235,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `i64` error[E0277]: `u8` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:81:40 --> $DIR/numbers.rs:81:40
@ -250,8 +250,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `f64` error[E0277]: `u8` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:82:40 --> $DIR/numbers.rs:82:40
@ -265,8 +265,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `u128` error[E0277]: `u8` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:83:39 --> $DIR/numbers.rs:83:39
@ -280,8 +280,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `i128` error[E0277]: `u8` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:84:39 --> $DIR/numbers.rs:84:39
@ -295,8 +295,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `i32` error[E0277]: `i16` cannot be safely transmuted into `i32`
--> $DIR/numbers.rs:86:40 --> $DIR/numbers.rs:86:40
@ -310,8 +310,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `f32` error[E0277]: `i16` cannot be safely transmuted into `f32`
--> $DIR/numbers.rs:87:40 --> $DIR/numbers.rs:87:40
@ -325,8 +325,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `u32` error[E0277]: `i16` cannot be safely transmuted into `u32`
--> $DIR/numbers.rs:88:40 --> $DIR/numbers.rs:88:40
@ -340,8 +340,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `u64` error[E0277]: `i16` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:89:40 --> $DIR/numbers.rs:89:40
@ -355,8 +355,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `i64` error[E0277]: `i16` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:90:40 --> $DIR/numbers.rs:90:40
@ -370,8 +370,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `f64` error[E0277]: `i16` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:91:40 --> $DIR/numbers.rs:91:40
@ -385,8 +385,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `u128` error[E0277]: `i16` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:92:39 --> $DIR/numbers.rs:92:39
@ -400,8 +400,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `i128` error[E0277]: `i16` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:93:39 --> $DIR/numbers.rs:93:39
@ -415,8 +415,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `i32` error[E0277]: `u16` cannot be safely transmuted into `i32`
--> $DIR/numbers.rs:95:40 --> $DIR/numbers.rs:95:40
@ -430,8 +430,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `f32` error[E0277]: `u16` cannot be safely transmuted into `f32`
--> $DIR/numbers.rs:96:40 --> $DIR/numbers.rs:96:40
@ -445,8 +445,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `u32` error[E0277]: `u16` cannot be safely transmuted into `u32`
--> $DIR/numbers.rs:97:40 --> $DIR/numbers.rs:97:40
@ -460,8 +460,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `u64` error[E0277]: `u16` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:98:40 --> $DIR/numbers.rs:98:40
@ -475,8 +475,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `i64` error[E0277]: `u16` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:99:40 --> $DIR/numbers.rs:99:40
@ -490,8 +490,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `f64` error[E0277]: `u16` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:100:40 --> $DIR/numbers.rs:100:40
@ -505,8 +505,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `u128` error[E0277]: `u16` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:101:39 --> $DIR/numbers.rs:101:39
@ -520,8 +520,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `i128` error[E0277]: `u16` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:102:39 --> $DIR/numbers.rs:102:39
@ -535,8 +535,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `u64` error[E0277]: `i32` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:104:40 --> $DIR/numbers.rs:104:40
@ -550,8 +550,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `i64` error[E0277]: `i32` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:105:40 --> $DIR/numbers.rs:105:40
@ -565,8 +565,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `f64` error[E0277]: `i32` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:106:40 --> $DIR/numbers.rs:106:40
@ -580,8 +580,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `u128` error[E0277]: `i32` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:107:39 --> $DIR/numbers.rs:107:39
@ -595,8 +595,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `i128` error[E0277]: `i32` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:108:39 --> $DIR/numbers.rs:108:39
@ -610,8 +610,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `u64` error[E0277]: `f32` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:110:40 --> $DIR/numbers.rs:110:40
@ -625,8 +625,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `i64` error[E0277]: `f32` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:111:40 --> $DIR/numbers.rs:111:40
@ -640,8 +640,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `f64` error[E0277]: `f32` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:112:40 --> $DIR/numbers.rs:112:40
@ -655,8 +655,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `u128` error[E0277]: `f32` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:113:39 --> $DIR/numbers.rs:113:39
@ -670,8 +670,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `i128` error[E0277]: `f32` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:114:39 --> $DIR/numbers.rs:114:39
@ -685,8 +685,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `u64` error[E0277]: `u32` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:116:40 --> $DIR/numbers.rs:116:40
@ -700,8 +700,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `i64` error[E0277]: `u32` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:117:40 --> $DIR/numbers.rs:117:40
@ -715,8 +715,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `f64` error[E0277]: `u32` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:118:40 --> $DIR/numbers.rs:118:40
@ -730,8 +730,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `u128` error[E0277]: `u32` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:119:39 --> $DIR/numbers.rs:119:39
@ -745,8 +745,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `i128` error[E0277]: `u32` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:120:39 --> $DIR/numbers.rs:120:39
@ -760,8 +760,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u64` cannot be safely transmuted into `u128` error[E0277]: `u64` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:122:39 --> $DIR/numbers.rs:122:39
@ -775,8 +775,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u64` cannot be safely transmuted into `i128` error[E0277]: `u64` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:123:39 --> $DIR/numbers.rs:123:39
@ -790,8 +790,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i64` cannot be safely transmuted into `u128` error[E0277]: `i64` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:125:39 --> $DIR/numbers.rs:125:39
@ -805,8 +805,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i64` cannot be safely transmuted into `i128` error[E0277]: `i64` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:126:39 --> $DIR/numbers.rs:126:39
@ -820,8 +820,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f64` cannot be safely transmuted into `u128` error[E0277]: `f64` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:128:39 --> $DIR/numbers.rs:128:39
@ -835,8 +835,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f64` cannot be safely transmuted into `i128` error[E0277]: `f64` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:129:39 --> $DIR/numbers.rs:129:39
@ -850,8 +850,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error: aborting due to 57 previous errors error: aborting due to 57 previous errors

228
tests/ui/transmutability/primitives/numbers.next.stderr
View file

@ -10,8 +10,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `u16` error[E0277]: `i8` cannot be safely transmuted into `u16`
--> $DIR/numbers.rs:65:40 --> $DIR/numbers.rs:65:40
@ -25,8 +25,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `i32` error[E0277]: `i8` cannot be safely transmuted into `i32`
--> $DIR/numbers.rs:66:40 --> $DIR/numbers.rs:66:40
@ -40,8 +40,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `f32` error[E0277]: `i8` cannot be safely transmuted into `f32`
--> $DIR/numbers.rs:67:40 --> $DIR/numbers.rs:67:40
@ -55,8 +55,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `u32` error[E0277]: `i8` cannot be safely transmuted into `u32`
--> $DIR/numbers.rs:68:40 --> $DIR/numbers.rs:68:40
@ -70,8 +70,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `u64` error[E0277]: `i8` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:69:40 --> $DIR/numbers.rs:69:40
@ -85,8 +85,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `i64` error[E0277]: `i8` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:70:40 --> $DIR/numbers.rs:70:40
@ -100,8 +100,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `f64` error[E0277]: `i8` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:71:40 --> $DIR/numbers.rs:71:40
@ -115,8 +115,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `u128` error[E0277]: `i8` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:72:39 --> $DIR/numbers.rs:72:39
@ -130,8 +130,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `i128` error[E0277]: `i8` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:73:39 --> $DIR/numbers.rs:73:39
@ -145,8 +145,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `i16` error[E0277]: `u8` cannot be safely transmuted into `i16`
--> $DIR/numbers.rs:75:40 --> $DIR/numbers.rs:75:40
@ -160,8 +160,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `u16` error[E0277]: `u8` cannot be safely transmuted into `u16`
--> $DIR/numbers.rs:76:40 --> $DIR/numbers.rs:76:40
@ -175,8 +175,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `i32` error[E0277]: `u8` cannot be safely transmuted into `i32`
--> $DIR/numbers.rs:77:40 --> $DIR/numbers.rs:77:40
@ -190,8 +190,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `f32` error[E0277]: `u8` cannot be safely transmuted into `f32`
--> $DIR/numbers.rs:78:40 --> $DIR/numbers.rs:78:40
@ -205,8 +205,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `u32` error[E0277]: `u8` cannot be safely transmuted into `u32`
--> $DIR/numbers.rs:79:40 --> $DIR/numbers.rs:79:40
@ -220,8 +220,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `u64` error[E0277]: `u8` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:80:40 --> $DIR/numbers.rs:80:40
@ -235,8 +235,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `i64` error[E0277]: `u8` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:81:40 --> $DIR/numbers.rs:81:40
@ -250,8 +250,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `f64` error[E0277]: `u8` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:82:40 --> $DIR/numbers.rs:82:40
@ -265,8 +265,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `u128` error[E0277]: `u8` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:83:39 --> $DIR/numbers.rs:83:39
@ -280,8 +280,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `i128` error[E0277]: `u8` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:84:39 --> $DIR/numbers.rs:84:39
@ -295,8 +295,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `i32` error[E0277]: `i16` cannot be safely transmuted into `i32`
--> $DIR/numbers.rs:86:40 --> $DIR/numbers.rs:86:40
@ -310,8 +310,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `f32` error[E0277]: `i16` cannot be safely transmuted into `f32`
--> $DIR/numbers.rs:87:40 --> $DIR/numbers.rs:87:40
@ -325,8 +325,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `u32` error[E0277]: `i16` cannot be safely transmuted into `u32`
--> $DIR/numbers.rs:88:40 --> $DIR/numbers.rs:88:40
@ -340,8 +340,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `u64` error[E0277]: `i16` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:89:40 --> $DIR/numbers.rs:89:40
@ -355,8 +355,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `i64` error[E0277]: `i16` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:90:40 --> $DIR/numbers.rs:90:40
@ -370,8 +370,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `f64` error[E0277]: `i16` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:91:40 --> $DIR/numbers.rs:91:40
@ -385,8 +385,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `u128` error[E0277]: `i16` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:92:39 --> $DIR/numbers.rs:92:39
@ -400,8 +400,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `i128` error[E0277]: `i16` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:93:39 --> $DIR/numbers.rs:93:39
@ -415,8 +415,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `i32` error[E0277]: `u16` cannot be safely transmuted into `i32`
--> $DIR/numbers.rs:95:40 --> $DIR/numbers.rs:95:40
@ -430,8 +430,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `f32` error[E0277]: `u16` cannot be safely transmuted into `f32`
--> $DIR/numbers.rs:96:40 --> $DIR/numbers.rs:96:40
@ -445,8 +445,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `u32` error[E0277]: `u16` cannot be safely transmuted into `u32`
--> $DIR/numbers.rs:97:40 --> $DIR/numbers.rs:97:40
@ -460,8 +460,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `u64` error[E0277]: `u16` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:98:40 --> $DIR/numbers.rs:98:40
@ -475,8 +475,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `i64` error[E0277]: `u16` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:99:40 --> $DIR/numbers.rs:99:40
@ -490,8 +490,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `f64` error[E0277]: `u16` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:100:40 --> $DIR/numbers.rs:100:40
@ -505,8 +505,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `u128` error[E0277]: `u16` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:101:39 --> $DIR/numbers.rs:101:39
@ -520,8 +520,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `i128` error[E0277]: `u16` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:102:39 --> $DIR/numbers.rs:102:39
@ -535,8 +535,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `u64` error[E0277]: `i32` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:104:40 --> $DIR/numbers.rs:104:40
@ -550,8 +550,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `i64` error[E0277]: `i32` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:105:40 --> $DIR/numbers.rs:105:40
@ -565,8 +565,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `f64` error[E0277]: `i32` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:106:40 --> $DIR/numbers.rs:106:40
@ -580,8 +580,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `u128` error[E0277]: `i32` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:107:39 --> $DIR/numbers.rs:107:39
@ -595,8 +595,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `i128` error[E0277]: `i32` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:108:39 --> $DIR/numbers.rs:108:39
@ -610,8 +610,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `u64` error[E0277]: `f32` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:110:40 --> $DIR/numbers.rs:110:40
@ -625,8 +625,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `i64` error[E0277]: `f32` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:111:40 --> $DIR/numbers.rs:111:40
@ -640,8 +640,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `f64` error[E0277]: `f32` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:112:40 --> $DIR/numbers.rs:112:40
@ -655,8 +655,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `u128` error[E0277]: `f32` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:113:39 --> $DIR/numbers.rs:113:39
@ -670,8 +670,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `i128` error[E0277]: `f32` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:114:39 --> $DIR/numbers.rs:114:39
@ -685,8 +685,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `u64` error[E0277]: `u32` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:116:40 --> $DIR/numbers.rs:116:40
@ -700,8 +700,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `i64` error[E0277]: `u32` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:117:40 --> $DIR/numbers.rs:117:40
@ -715,8 +715,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `f64` error[E0277]: `u32` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:118:40 --> $DIR/numbers.rs:118:40
@ -730,8 +730,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `u128` error[E0277]: `u32` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:119:39 --> $DIR/numbers.rs:119:39
@ -745,8 +745,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `i128` error[E0277]: `u32` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:120:39 --> $DIR/numbers.rs:120:39
@ -760,8 +760,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u64` cannot be safely transmuted into `u128` error[E0277]: `u64` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:122:39 --> $DIR/numbers.rs:122:39
@ -775,8 +775,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u64` cannot be safely transmuted into `i128` error[E0277]: `u64` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:123:39 --> $DIR/numbers.rs:123:39
@ -790,8 +790,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i64` cannot be safely transmuted into `u128` error[E0277]: `i64` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:125:39 --> $DIR/numbers.rs:125:39
@ -805,8 +805,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i64` cannot be safely transmuted into `i128` error[E0277]: `i64` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:126:39 --> $DIR/numbers.rs:126:39
@ -820,8 +820,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f64` cannot be safely transmuted into `u128` error[E0277]: `f64` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:128:39 --> $DIR/numbers.rs:128:39
@ -835,8 +835,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f64` cannot be safely transmuted into `i128` error[E0277]: `f64` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:129:39 --> $DIR/numbers.rs:129:39
@ -850,8 +850,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> LL | Dst: TransmuteFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error: aborting due to 57 previous errors error: aborting due to 57 previous errors

4
tests/ui/transmutability/primitives/numbers.rs
View file

@ -7,11 +7,11 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::TransmuteFrom;
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src> Dst: TransmuteFrom<Src>
{} {}
} }

2
tests/ui/transmutability/primitives/unit.current.stderr
View file

@ -10,7 +10,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume::ALIGNMENT LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES) LL | | .and(Assume::LIFETIMES)

2
tests/ui/transmutability/primitives/unit.next.stderr
View file

@ -10,7 +10,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume::ALIGNMENT LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES) LL | | .and(Assume::LIFETIMES)

4
tests/ui/transmutability/primitives/unit.rs
View file

@ -9,11 +9,11 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume::ALIGNMENT Assume::ALIGNMENT
.and(Assume::LIFETIMES) .and(Assume::LIFETIMES)
.and(Assume::SAFETY) .and(Assume::SAFETY)

6
tests/ui/transmutability/references/accept_assume_lifetime_extension.rs
View file

@ -4,11 +4,11 @@
#![feature(transmutability, core_intrinsics)] #![feature(transmutability, core_intrinsics)]
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
unsafe fn transmute<Src, Dst>(src: Src) -> Dst unsafe fn transmute<Src, Dst>(src: Src) -> Dst
where where
Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY.and(Assume::LIFETIMES) }>, Dst: TransmuteFrom<Src, { Assume::SAFETY.and(Assume::LIFETIMES) }>,
{ {
core::intrinsics::transmute_unchecked(src) core::intrinsics::transmute_unchecked(src)
} }
@ -82,7 +82,7 @@ mod hrtb {
unsafe fn extend_hrtb<'a>(src: &'a u8) -> &'static u8 unsafe fn extend_hrtb<'a>(src: &'a u8) -> &'static u8
where where
for<'b> &'b u8: BikeshedIntrinsicFrom<&'a u8, { Assume::LIFETIMES }>, for<'b> &'b u8: TransmuteFrom<&'a u8, { Assume::LIFETIMES }>,
{ {
core::intrinsics::transmute_unchecked(src) core::intrinsics::transmute_unchecked(src)
} }

4
tests/ui/transmutability/references/accept_unexercised_lifetime_extension.rs
View file

@ -4,11 +4,11 @@
#![feature(transmutability, core_intrinsics)] #![feature(transmutability, core_intrinsics)]
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
unsafe fn transmute<Src, Dst>(src: Src) -> Dst unsafe fn transmute<Src, Dst>(src: Src) -> Dst
where where
Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>, Dst: TransmuteFrom<Src, { Assume::SAFETY }>,
{ {
core::intrinsics::transmute_unchecked(src) core::intrinsics::transmute_unchecked(src)
} }

4
tests/ui/transmutability/references/recursive-wrapper-types-bit-compatible-mut.rs
View file

@ -2,11 +2,11 @@
#![feature(transmutability)] #![feature(transmutability)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: true, alignment: true,
lifetimes: false, lifetimes: false,

2
tests/ui/transmutability/references/recursive-wrapper-types-bit-compatible-mut.stderr
View file

@ -10,7 +10,7 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,

4
tests/ui/transmutability/references/recursive-wrapper-types-bit-compatible.rs
View file

@ -2,11 +2,11 @@
#![feature(transmutability)] #![feature(transmutability)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: true, alignment: true,
lifetimes: false, lifetimes: false,

4
tests/ui/transmutability/references/recursive-wrapper-types-bit-incompatible.rs
View file

@ -2,11 +2,11 @@
#![feature(transmutability)] #![feature(transmutability)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: true, alignment: true,
lifetimes: false, lifetimes: false,

2
tests/ui/transmutability/references/recursive-wrapper-types-bit-incompatible.stderr
View file

@ -10,7 +10,7 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,

4
tests/ui/transmutability/references/recursive-wrapper-types.rs
View file

@ -2,11 +2,11 @@
#![feature(transmutability)] #![feature(transmutability)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: true, alignment: true,
lifetimes: false, lifetimes: false,

4
tests/ui/transmutability/references/reject_extension.rs
View file

@ -6,11 +6,11 @@
#![feature(transmutability)] #![feature(transmutability)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom< Dst: TransmuteFrom<
Src, Src,
{ {
Assume { Assume {

2
tests/ui/transmutability/references/reject_extension.stderr
View file

@ -10,7 +10,7 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom< LL | Dst: TransmuteFrom<
| ______________^ | ______________^
LL | | Src, LL | | Src,
LL | | { LL | | {

6
tests/ui/transmutability/references/reject_lifetime_extension.rs
View file

@ -4,11 +4,11 @@
#![feature(transmutability, core_intrinsics)] #![feature(transmutability, core_intrinsics)]
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
unsafe fn transmute<Src, Dst>(src: Src) -> Dst unsafe fn transmute<Src, Dst>(src: Src) -> Dst
where where
Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>, Dst: TransmuteFrom<Src, { Assume::SAFETY }>,
{ {
core::intrinsics::transmute_unchecked(src) core::intrinsics::transmute_unchecked(src)
} }
@ -82,7 +82,7 @@ mod hrtb {
unsafe fn extend_hrtb<'a>(src: &'a u8) -> &'static u8 unsafe fn extend_hrtb<'a>(src: &'a u8) -> &'static u8
where where
for<'b> &'b u8: BikeshedIntrinsicFrom<&'a u8>, for<'b> &'b u8: TransmuteFrom<&'a u8>,
{ {
core::intrinsics::transmute_unchecked(src) core::intrinsics::transmute_unchecked(src)
} }

4
tests/ui/transmutability/references/reject_lifetime_extension.stderr
View file

@ -70,8 +70,8 @@ LL | unsafe { extend_hrtb(src) }
note: due to current limitations in the borrow checker, this implies a `'static` lifetime note: due to current limitations in the borrow checker, this implies a `'static` lifetime
--> $DIR/reject_lifetime_extension.rs:85:25 --> $DIR/reject_lifetime_extension.rs:85:25
| |
LL | for<'b> &'b u8: BikeshedIntrinsicFrom<&'a u8>, LL | for<'b> &'b u8: TransmuteFrom<&'a u8>,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 8 previous errors error: aborting due to 8 previous errors

4
tests/ui/transmutability/references/u8-to-unit.rs
View file

@ -2,11 +2,11 @@
#![feature(transmutability)] #![feature(transmutability)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: false, alignment: false,
lifetimes: true, lifetimes: true,

4
tests/ui/transmutability/references/unit-to-itself.rs
View file

@ -2,11 +2,11 @@
#![feature(transmutability)] #![feature(transmutability)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: true, alignment: true,
lifetimes: false, lifetimes: false,

4
tests/ui/transmutability/references/unit-to-u8.rs
View file

@ -2,11 +2,11 @@
#![feature(transmutability)] #![feature(transmutability)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: true, alignment: true,
lifetimes: true, lifetimes: true,

2
tests/ui/transmutability/references/unit-to-u8.stderr
View file

@ -10,7 +10,7 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,

4
tests/ui/transmutability/references/unsafecell.rs
View file

@ -5,11 +5,11 @@
use std::cell::UnsafeCell; use std::cell::UnsafeCell;
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }> Dst: TransmuteFrom<Src, { Assume::SAFETY }>
{} {}
} }

8
tests/ui/transmutability/references/unsafecell.stderr
View file

@ -10,8 +10,8 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }> LL | Dst: TransmuteFrom<Src, { Assume::SAFETY }>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
error[E0277]: `&UnsafeCell<u8>` cannot be safely transmuted into `&UnsafeCell<u8>` error[E0277]: `&UnsafeCell<u8>` cannot be safely transmuted into `&UnsafeCell<u8>`
--> $DIR/unsafecell.rs:29:62 --> $DIR/unsafecell.rs:29:62
@ -25,8 +25,8 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }> LL | Dst: TransmuteFrom<Src, { Assume::SAFETY }>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
error: aborting due to 2 previous errors error: aborting due to 2 previous errors

4
tests/ui/transmutability/region-infer.rs
View file

@ -1,13 +1,13 @@
#![feature(transmutability)] #![feature(transmutability)]
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
#[repr(C)] #[repr(C)]
struct W<'a>(&'a ()); struct W<'a>(&'a ());
fn test<'a>() fn test<'a>()
where where
W<'a>: BikeshedIntrinsicFrom< W<'a>: TransmuteFrom<
(), (),
{ Assume { alignment: true, lifetimes: true, safety: true, validity: true } }, { Assume { alignment: true, lifetimes: true, safety: true, validity: true } },
>, >,

2
tests/ui/transmutability/region-infer.stderr
View file

@ -10,7 +10,7 @@ note: required by a bound in `test`
LL | fn test<'a>() LL | fn test<'a>()
| ---- required by a bound in this function | ---- required by a bound in this function
LL | where LL | where
LL | W<'a>: BikeshedIntrinsicFrom< LL | W<'a>: TransmuteFrom<
| ____________^ | ____________^
LL | | (), LL | | (),
LL | | { Assume { alignment: true, lifetimes: true, safety: true, validity: true } }, LL | | { Assume { alignment: true, lifetimes: true, safety: true, validity: true } },

4
tests/ui/transmutability/safety/assume/should_accept_if_dst_has_safety_invariant.rs
View file

@ -8,11 +8,11 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }> Dst: TransmuteFrom<Src, { Assume::SAFETY }>
{} {}
} }

4
tests/ui/transmutability/safety/assume/should_accept_if_ref_src_has_safety_invariant.rs
View file

@ -8,11 +8,11 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }> Dst: TransmuteFrom<Src, { Assume::SAFETY }>
{} {}
} }

4
tests/ui/transmutability/safety/assume/should_accept_if_src_has_safety_invariant.rs
View file

@ -8,11 +8,11 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }> Dst: TransmuteFrom<Src, { Assume::SAFETY }>
{} {}
} }

4
tests/ui/transmutability/safety/should_accept_if_src_has_safety_invariant.rs
View file

@ -8,11 +8,11 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::TransmuteFrom;
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src> // safety is NOT assumed Dst: TransmuteFrom<Src> // safety is NOT assumed
{} {}
} }

4
tests/ui/transmutability/safety/should_reject_if_dst_has_safety_invariant.rs
View file

@ -6,11 +6,11 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::TransmuteFrom;
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src> // safety is NOT assumed Dst: TransmuteFrom<Src> // safety is NOT assumed
{} {}
} }

4
tests/ui/transmutability/safety/should_reject_if_dst_has_safety_invariant.stderr
View file

@ -10,8 +10,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> // safety is NOT assumed LL | Dst: TransmuteFrom<Src> // safety is NOT assumed
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error: aborting due to 1 previous error error: aborting due to 1 previous error

4
tests/ui/transmutability/safety/should_reject_if_ref_src_has_safety_invariant.rs
View file

@ -6,11 +6,11 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::TransmuteFrom;
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src> // safety is NOT assumed Dst: TransmuteFrom<Src> // safety is NOT assumed
{} {}
} }

4
tests/ui/transmutability/safety/should_reject_if_ref_src_has_safety_invariant.stderr
View file

@ -10,8 +10,8 @@ note: required by a bound in `is_transmutable`
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src> // safety is NOT assumed LL | Dst: TransmuteFrom<Src> // safety is NOT assumed
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error: aborting due to 1 previous error error: aborting due to 1 previous error

4
tests/ui/transmutability/structs/repr/should_handle_align.rs
View file

@ -6,11 +6,11 @@
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: true, alignment: true,
lifetimes: true, lifetimes: true,

4
tests/ui/transmutability/structs/repr/should_handle_all.rs
View file

@ -6,11 +6,11 @@
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: true, alignment: true,
lifetimes: true, lifetimes: true,

4
tests/ui/transmutability/structs/repr/should_handle_packed.rs
View file

@ -6,11 +6,11 @@
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: true, alignment: true,
lifetimes: true, lifetimes: true,

4
tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.rs
View file

@ -7,11 +7,11 @@
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src>, Dst: TransmuteFrom<Src>,
{ {
} }
} }

2
tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.stderr
View file

@ -12,7 +12,7 @@ LL | struct ExplicitlyPadded(Box<ExplicitlyPadded>);
error[E0391]: cycle detected when computing layout of `should_pad_explicitly_packed_field::ExplicitlyPadded` error[E0391]: cycle detected when computing layout of `should_pad_explicitly_packed_field::ExplicitlyPadded`
| |
= note: ...which immediately requires computing layout of `should_pad_explicitly_packed_field::ExplicitlyPadded` again = note: ...which immediately requires computing layout of `should_pad_explicitly_packed_field::ExplicitlyPadded` again
= note: cycle used when evaluating trait selection obligation `(): core::mem::transmutability::BikeshedIntrinsicFrom<should_pad_explicitly_packed_field::ExplicitlyPadded, core::mem::transmutability::Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` = note: cycle used when evaluating trait selection obligation `(): core::mem::transmutability::TransmuteFrom<should_pad_explicitly_packed_field::ExplicitlyPadded, core::mem::transmutability::Assume { alignment: false, lifetimes: false, safety: false, validity: false }>`
= note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
error: aborting due to 2 previous errors error: aborting due to 2 previous errors

4
tests/ui/transmutability/structs/should_order_fields_correctly.rs
View file

@ -6,11 +6,11 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume::ALIGNMENT Assume::ALIGNMENT
.and(Assume::LIFETIMES) .and(Assume::LIFETIMES)
.and(Assume::SAFETY) .and(Assume::SAFETY)

4
tests/ui/transmutability/transmute-padding-ice.rs
View file

@ -9,11 +9,11 @@
use std::mem::size_of; use std::mem::size_of;
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom< Dst: TransmuteFrom<
Src, Src,
{ Assume { alignment: true, lifetimes: true, safety: true, validity: true } }, { Assume { alignment: true, lifetimes: true, safety: true, validity: true } },
>, >,

4
tests/ui/transmutability/uninhabited.rs
View file

@ -3,11 +3,11 @@
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Dst: TransmuteFrom<Src, {
Assume { Assume {
alignment: true, alignment: true,
lifetimes: true, lifetimes: true,

8
tests/ui/transmutability/uninhabited.stderr
View file

@ -34,7 +34,7 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -56,7 +56,7 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -78,7 +78,7 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,
@ -100,7 +100,7 @@ note: required by a bound in `is_maybe_transmutable`
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this function | --------------------- required by a bound in this function
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, { LL | Dst: TransmuteFrom<Src, {
| ______________^ | ______________^
LL | | Assume { LL | | Assume {
LL | | alignment: true, LL | | alignment: true,

4
tests/ui/transmutability/unions/boolish.rs
View file

@ -6,11 +6,11 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, TransmuteFrom};
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }> Dst: TransmuteFrom<Src, { Assume::SAFETY }>
{} {}
} }

Some files were not shown because too many files have changed in this diff Show more