Auto merge of #100726 - jswrenn:transmute, r=oli-obk

safe transmute: use `Assume` struct to provide analysis options

This task was left as a TODO in #92268; resolving it brings [`BikeshedIntrinsicFrom`](https://doc.rust-lang.org/nightly/core/mem/trait.BikeshedIntrinsicFrom.html) more in line with the API defined in [MCP411](https://github.com/rust-lang/compiler-team/issues/411).

**Before:**
```rust
pub unsafe trait BikeshedIntrinsicFrom<
    Src,
    Context,
    const ASSUME_ALIGNMENT: bool,
    const ASSUME_LIFETIMES: bool,
    const ASSUME_VALIDITY: bool,
    const ASSUME_VISIBILITY: bool,
> where
    Src: ?Sized,
{}
```
**After:**
```rust
pub unsafe trait BikeshedIntrinsicFrom<Src, Context, const ASSUME: Assume = { Assume::NOTHING }>
where
    Src: ?Sized,
{}
```

`Assume::visibility` has also been renamed to `Assume::safety`, as library safety invariants are what's actually being assumed; visibility is just the mechanism by which it is currently checked (and that may change).

r? `@oli-obk`

---

Related:
- https://github.com/rust-lang/compiler-team/issues/411
- https://github.com/rust-lang/rust/issues/99571
This commit is contained in:
bors 2022-09-04 07:55:44 +00:00
commit 8521a8c92d
79 changed files with 1320 additions and 735 deletions

View File

@ -4234,6 +4234,7 @@ version = "0.1.0"
dependencies = [ dependencies = [
"itertools", "itertools",
"rustc_data_structures", "rustc_data_structures",
"rustc_hir",
"rustc_infer", "rustc_infer",
"rustc_macros", "rustc_macros",
"rustc_middle", "rustc_middle",

View File

@ -193,7 +193,8 @@ language_item_table! {
DispatchFromDyn, sym::dispatch_from_dyn, dispatch_from_dyn_trait, Target::Trait, GenericRequirement::Minimum(1); DispatchFromDyn, sym::dispatch_from_dyn, dispatch_from_dyn_trait, Target::Trait, GenericRequirement::Minimum(1);
// language items relating to transmutability // language items relating to transmutability
TransmuteTrait, sym::transmute_trait, transmute_trait, Target::Trait, GenericRequirement::Exact(6); TransmuteOpts, sym::transmute_opts, transmute_opts, Target::Struct, GenericRequirement::Exact(0);
TransmuteTrait, sym::transmute_trait, transmute_trait, Target::Trait, GenericRequirement::Exact(3);
Add(Op), sym::add, add_trait, Target::Trait, GenericRequirement::Exact(1); Add(Op), sym::add, add_trait, Target::Trait, GenericRequirement::Exact(1);
Sub(Op), sym::sub, sub_trait, Target::Trait, GenericRequirement::Exact(1); Sub(Op), sym::sub, sub_trait, Target::Trait, GenericRequirement::Exact(1);

View File

@ -339,6 +339,7 @@ symbols! {
alias, alias,
align, align,
align_offset, align_offset,
alignment,
alignstack, alignstack,
all, all,
alloc, alloc,
@ -866,6 +867,7 @@ symbols! {
lib, lib,
libc, libc,
lifetime, lifetime,
lifetimes,
likely, likely,
line, line,
line_macro, line_macro,
@ -1294,6 +1296,7 @@ symbols! {
rustfmt, rustfmt,
rvalue_static_promotion, rvalue_static_promotion,
s, s,
safety,
sanitize, sanitize,
sanitizer_runtime, sanitizer_runtime,
saturating_add, saturating_add,
@ -1478,6 +1481,7 @@ symbols! {
trait_alias, trait_alias,
trait_upcasting, trait_upcasting,
transmute, transmute,
transmute_opts,
transmute_trait, transmute_trait,
transparent, transparent,
transparent_enums, transparent_enums,
@ -1573,6 +1577,7 @@ symbols! {
va_list, va_list,
va_start, va_start,
val, val,
validity,
values, values,
var, var,
variant_count, variant_count,

View File

@ -279,29 +279,17 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
let predicate = obligation.predicate; let predicate = obligation.predicate;
let type_at = |i| predicate.map_bound(|p| p.trait_ref.substs.type_at(i)); let type_at = |i| predicate.map_bound(|p| p.trait_ref.substs.type_at(i));
let bool_at = |i| { let const_at = |i| predicate.skip_binder().trait_ref.substs.const_at(i);
predicate
.skip_binder()
.trait_ref
.substs
.const_at(i)
.try_eval_bool(self.tcx(), obligation.param_env)
.unwrap_or(true)
};
let src_and_dst = predicate.map_bound(|p| rustc_transmute::Types { let src_and_dst = predicate.map_bound(|p| rustc_transmute::Types {
src: p.trait_ref.substs.type_at(1),
dst: p.trait_ref.substs.type_at(0), dst: p.trait_ref.substs.type_at(0),
src: p.trait_ref.substs.type_at(1),
}); });
let scope = type_at(2).skip_binder(); let scope = type_at(2).skip_binder();
let assume = rustc_transmute::Assume { let assume =
alignment: bool_at(3), rustc_transmute::Assume::from_const(self.infcx.tcx, obligation.param_env, const_at(3));
lifetimes: bool_at(4),
validity: bool_at(5),
visibility: bool_at(6),
};
let cause = obligation.cause.clone(); let cause = obligation.cause.clone();

View File

@ -7,7 +7,8 @@ edition = "2021"
[dependencies] [dependencies]
tracing = "0.1" tracing = "0.1"
rustc_data_structures = { path = "../rustc_data_structures", optional = true} rustc_data_structures = { path = "../rustc_data_structures"}
rustc_hir = { path = "../rustc_hir", optional = true}
rustc_infer = { path = "../rustc_infer", optional = true} rustc_infer = { path = "../rustc_infer", optional = true}
rustc_macros = { path = "../rustc_macros", optional = true} rustc_macros = { path = "../rustc_macros", optional = true}
rustc_middle = { path = "../rustc_middle", optional = true} rustc_middle = { path = "../rustc_middle", optional = true}
@ -17,7 +18,7 @@ rustc_target = { path = "../rustc_target", optional = true}
[features] [features]
rustc = [ rustc = [
"rustc_middle", "rustc_middle",
"rustc_data_structures", "rustc_hir",
"rustc_infer", "rustc_infer",
"rustc_macros", "rustc_macros",
"rustc_span", "rustc_span",

View File

@ -104,7 +104,6 @@ where
} }
#[instrument(level = "debug")] #[instrument(level = "debug")]
#[cfg_attr(feature = "rustc", allow(rustc::potential_query_instability))]
pub(crate) fn from_nfa(nfa: Nfa<R>) -> Self { pub(crate) fn from_nfa(nfa: Nfa<R>) -> Self {
let Nfa { transitions: nfa_transitions, start: nfa_start, accepting: nfa_accepting } = nfa; let Nfa { transitions: nfa_transitions, start: nfa_start, accepting: nfa_accepting } = nfa;

View File

@ -119,8 +119,6 @@ where
let mut transitions: Map<State, Map<Transition<R>, Set<State>>> = self.transitions; let mut transitions: Map<State, Map<Transition<R>, Set<State>>> = self.transitions;
// the iteration order doesn't matter
#[cfg_attr(feature = "rustc", allow(rustc::potential_query_instability))]
for (source, transition) in other.transitions { for (source, transition) in other.transitions {
let fix_state = |state| if state == other.start { self.accepting } else { state }; let fix_state = |state| if state == other.start { self.accepting } else { state };
let entry = transitions.entry(fix_state(source)).or_default(); let entry = transitions.entry(fix_state(source)).or_default();
@ -142,8 +140,6 @@ where
let mut transitions: Map<State, Map<Transition<R>, Set<State>>> = self.transitions.clone(); let mut transitions: Map<State, Map<Transition<R>, Set<State>>> = self.transitions.clone();
// the iteration order doesn't matter
#[cfg_attr(feature = "rustc", allow(rustc::potential_query_instability))]
for (&(mut source), transition) in other.transitions.iter() { for (&(mut source), transition) in other.transitions.iter() {
// if source is starting state of `other`, replace with starting state of `self` // if source is starting state of `other`, replace with starting state of `self`
if source == other.start { if source == other.start {
@ -152,8 +148,6 @@ where
let entry = transitions.entry(source).or_default(); let entry = transitions.entry(source).or_default();
for (edge, destinations) in transition { for (edge, destinations) in transition {
let entry = entry.entry(edge.clone()).or_default(); let entry = entry.entry(edge.clone()).or_default();
// the iteration order doesn't matter
#[cfg_attr(feature = "rustc", allow(rustc::potential_query_instability))]
for &(mut destination) in destinations { for &(mut destination) in destinations {
// if dest is accepting state of `other`, replace with accepting state of `self` // if dest is accepting state of `other`, replace with accepting state of `self`
if destination == other.accepting { if destination == other.accepting {

View File

@ -6,11 +6,7 @@
#[macro_use] #[macro_use]
extern crate tracing; extern crate tracing;
#[cfg(feature = "rustc")] pub(crate) use rustc_data_structures::fx::{FxIndexMap as Map, FxIndexSet as Set};
pub(crate) use rustc_data_structures::fx::{FxHashMap as Map, FxHashSet as Set};
#[cfg(not(feature = "rustc"))]
pub(crate) use std::collections::{HashMap as Map, HashSet as Set};
pub(crate) mod layout; pub(crate) mod layout;
pub(crate) mod maybe_transmutable; pub(crate) mod maybe_transmutable;
@ -19,8 +15,8 @@ pub(crate) mod maybe_transmutable;
pub struct Assume { pub struct Assume {
pub alignment: bool, pub alignment: bool,
pub lifetimes: bool, pub lifetimes: bool,
pub safety: bool,
pub validity: bool, pub validity: bool,
pub visibility: bool,
} }
/// The type encodes answers to the question: "Are these types transmutable?" /// The type encodes answers to the question: "Are these types transmutable?"
@ -62,11 +58,17 @@ pub enum Reason {
#[cfg(feature = "rustc")] #[cfg(feature = "rustc")]
mod rustc { mod rustc {
use super::*;
use rustc_hir::lang_items::LangItem;
use rustc_infer::infer::InferCtxt; use rustc_infer::infer::InferCtxt;
use rustc_macros::{TypeFoldable, TypeVisitable}; use rustc_macros::{TypeFoldable, TypeVisitable};
use rustc_middle::traits::ObligationCause; use rustc_middle::traits::ObligationCause;
use rustc_middle::ty::Binder; use rustc_middle::ty::Binder;
use rustc_middle::ty::Const;
use rustc_middle::ty::ParamEnv;
use rustc_middle::ty::Ty; use rustc_middle::ty::Ty;
use rustc_middle::ty::TyCtxt;
/// The source and destination types of a transmutation. /// The source and destination types of a transmutation.
#[derive(TypeFoldable, TypeVisitable, Debug, Clone, Copy)] #[derive(TypeFoldable, TypeVisitable, Debug, Clone, Copy)]
@ -106,6 +108,54 @@ mod rustc {
.answer() .answer()
} }
} }
impl Assume {
/// Constructs an `Assume` from a given const-`Assume`.
pub fn from_const<'tcx>(
tcx: TyCtxt<'tcx>,
param_env: ParamEnv<'tcx>,
c: Const<'tcx>,
) -> Self {
use rustc_middle::ty::ScalarInt;
use rustc_middle::ty::TypeVisitable;
use rustc_span::symbol::sym;
let c = c.eval(tcx, param_env);
if let Some(err) = c.error_reported() {
return Self { alignment: true, lifetimes: true, safety: true, validity: true };
}
let adt_def = c.ty().ty_adt_def().expect("The given `Const` must be an ADT.");
assert_eq!(
tcx.require_lang_item(LangItem::TransmuteOpts, None),
adt_def.did(),
"The given `Const` was not marked with the `{}` lang item.",
LangItem::TransmuteOpts.name(),
);
let variant = adt_def.non_enum_variant();
let fields = c.to_valtree().unwrap_branch();
let get_field = |name| {
let (field_idx, _) = variant
.fields
.iter()
.enumerate()
.find(|(_, field_def)| name == field_def.name)
.expect(&format!("There were no fields named `{name}`."));
fields[field_idx].unwrap_leaf() == ScalarInt::TRUE
};
Self {
alignment: get_field(sym::alignment),
lifetimes: get_field(sym::lifetimes),
safety: get_field(sym::safety),
validity: get_field(sym::validity),
}
}
}
} }
#[cfg(feature = "rustc")] #[cfg(feature = "rustc")]

View File

@ -105,7 +105,7 @@ where
#[inline(always)] #[inline(always)]
#[instrument(level = "debug", skip(self), fields(src = ?self.src, dst = ?self.dst))] #[instrument(level = "debug", skip(self), fields(src = ?self.src, dst = ?self.dst))]
pub(crate) fn answer(self) -> Answer<<C as QueryContext>::Ref> { pub(crate) fn answer(self) -> Answer<<C as QueryContext>::Ref> {
let assume_visibility = self.assume.visibility; let assume_visibility = self.assume.safety;
let query_or_answer = self.map_layouts(|src, dst, scope, context| { let query_or_answer = self.map_layouts(|src, dst, scope, context| {
// Remove all `Def` nodes from `src`, without checking their visibility. // Remove all `Def` nodes from `src`, without checking their visibility.
let src = src.prune(&|def| true); let src = src.prune(&|def| true);

View File

@ -13,7 +13,7 @@ mod bool {
layout::Tree::<Def, !>::bool(), layout::Tree::<Def, !>::bool(),
layout::Tree::<Def, !>::bool(), layout::Tree::<Def, !>::bool(),
(), (),
crate::Assume { alignment: false, lifetimes: false, validity: true, visibility: false }, crate::Assume { alignment: false, lifetimes: false, validity: true, safety: false },
UltraMinimal, UltraMinimal,
) )
.answer(); .answer();
@ -26,7 +26,7 @@ mod bool {
layout::Dfa::<!>::bool(), layout::Dfa::<!>::bool(),
layout::Dfa::<!>::bool(), layout::Dfa::<!>::bool(),
(), (),
crate::Assume { alignment: false, lifetimes: false, validity: true, visibility: false }, crate::Assume { alignment: false, lifetimes: false, validity: true, safety: false },
UltraMinimal, UltraMinimal,
) )
.answer(); .answer();

View File

@ -93,6 +93,7 @@
#![warn(missing_debug_implementations)] #![warn(missing_debug_implementations)]
#![warn(missing_docs)] #![warn(missing_docs)]
#![allow(explicit_outlives_requirements)] #![allow(explicit_outlives_requirements)]
#![allow(incomplete_features)]
// //
// Library features: // Library features:
#![feature(const_align_offset)] #![feature(const_align_offset)]
@ -160,6 +161,7 @@
// //
// Language features: // Language features:
#![feature(abi_unadjusted)] #![feature(abi_unadjusted)]
#![feature(adt_const_params)]
#![feature(allow_internal_unsafe)] #![feature(allow_internal_unsafe)]
#![feature(allow_internal_unstable)] #![feature(allow_internal_unstable)]
#![feature(associated_type_bounds)] #![feature(associated_type_bounds)]

View File

@ -4,25 +4,20 @@
/// any value of type `Self` are safely transmutable into a value of type `Dst`, in a given `Context`, /// any value of type `Self` are safely transmutable into a value of type `Dst`, in a given `Context`,
/// notwithstanding whatever safety checks you have asked the compiler to [`Assume`] are satisfied. /// notwithstanding whatever safety checks you have asked the compiler to [`Assume`] are satisfied.
#[unstable(feature = "transmutability", issue = "99571")] #[unstable(feature = "transmutability", issue = "99571")]
#[lang = "transmute_trait"] #[cfg_attr(not(bootstrap), lang = "transmute_trait")]
#[rustc_on_unimplemented( #[rustc_on_unimplemented(
message = "`{Src}` cannot be safely transmuted into `{Self}` in the defining scope of `{Context}`.", message = "`{Src}` cannot be safely transmuted into `{Self}` in the defining scope of `{Context}`.",
label = "`{Src}` cannot be safely transmuted into `{Self}` in the defining scope of `{Context}`." label = "`{Src}` cannot be safely transmuted into `{Self}` in the defining scope of `{Context}`."
)] )]
pub unsafe trait BikeshedIntrinsicFrom< pub unsafe trait BikeshedIntrinsicFrom<Src, Context, const ASSUME: Assume = { Assume::NOTHING }>
Src, where
Context,
const ASSUME_ALIGNMENT: bool,
const ASSUME_LIFETIMES: bool,
const ASSUME_VALIDITY: bool,
const ASSUME_VISIBILITY: bool,
> where
Src: ?Sized, Src: ?Sized,
{ {
} }
/// What transmutation safety conditions shall the compiler assume that *you* are checking? /// What transmutation safety conditions shall the compiler assume that *you* are checking?
#[unstable(feature = "transmutability", issue = "99571")] #[unstable(feature = "transmutability", issue = "99571")]
#[cfg_attr(not(bootstrap), lang = "transmute_opts")]
#[derive(PartialEq, Eq, Clone, Copy, Debug)] #[derive(PartialEq, Eq, Clone, Copy, Debug)]
pub struct Assume { pub struct Assume {
/// When `true`, the compiler assumes that *you* are ensuring (either dynamically or statically) that /// When `true`, the compiler assumes that *you* are ensuring (either dynamically or statically) that
@ -33,11 +28,80 @@ pub struct Assume {
/// that violates Rust's memory model. /// that violates Rust's memory model.
pub lifetimes: bool, pub lifetimes: bool,
/// When `true`, the compiler assumes that *you* have ensured that it is safe for you to violate the
/// type and field privacy of the destination type (and sometimes of the source type, too).
pub safety: bool,
/// When `true`, the compiler assumes that *you* are ensuring that the source type is actually a valid /// When `true`, the compiler assumes that *you* are ensuring that the source type is actually a valid
/// instance of the destination type. /// instance of the destination type.
pub validity: bool, pub validity: bool,
}
/// When `true`, the compiler assumes that *you* have ensured that it is safe for you to violate the
/// type and field privacy of the destination type (and sometimes of the source type, too). impl Assume {
pub visibility: bool, /// Do not assume that *you* have ensured any safety properties are met.
#[unstable(feature = "transmutability", issue = "99571")]
pub const NOTHING: Self =
Self { alignment: false, lifetimes: false, safety: false, validity: false };
/// Assume only that alignment conditions are met.
#[unstable(feature = "transmutability", issue = "99571")]
pub const ALIGNMENT: Self = Self { alignment: true, ..Self::NOTHING };
/// Assume only that lifetime conditions are met.
#[unstable(feature = "transmutability", issue = "99571")]
pub const LIFETIMES: Self = Self { lifetimes: true, ..Self::NOTHING };
/// Assume only that safety conditions are met.
#[unstable(feature = "transmutability", issue = "99571")]
pub const SAFETY: Self = Self { safety: true, ..Self::NOTHING };
/// Assume only that dynamically-satisfiable validity conditions are met.
#[unstable(feature = "transmutability", issue = "99571")]
pub const VALIDITY: Self = Self { validity: true, ..Self::NOTHING };
/// Assume both `self` and `other_assumptions`.
#[unstable(feature = "transmutability", issue = "99571")]
pub const fn and(self, other_assumptions: Self) -> Self {
Self {
alignment: self.alignment || other_assumptions.alignment,
lifetimes: self.lifetimes || other_assumptions.lifetimes,
safety: self.safety || other_assumptions.safety,
validity: self.validity || other_assumptions.validity,
}
}
/// Assume `self`, excepting `other_assumptions`.
#[unstable(feature = "transmutability", issue = "99571")]
pub const fn but_not(self, other_assumptions: Self) -> Self {
Self {
alignment: self.alignment && !other_assumptions.alignment,
lifetimes: self.lifetimes && !other_assumptions.lifetimes,
safety: self.safety && !other_assumptions.safety,
validity: self.validity && !other_assumptions.validity,
}
}
}
// FIXME(jswrenn): This const op is not actually usable. Why?
// https://github.com/rust-lang/rust/pull/100726#issuecomment-1219928926
#[unstable(feature = "transmutability", issue = "99571")]
#[rustc_const_unstable(feature = "transmutability", issue = "99571")]
impl const core::ops::Add for Assume {
type Output = Assume;
fn add(self, other_assumptions: Assume) -> Assume {
self.and(other_assumptions)
}
}
// FIXME(jswrenn): This const op is not actually usable. Why?
// https://github.com/rust-lang/rust/pull/100726#issuecomment-1219928926
#[unstable(feature = "transmutability", issue = "99571")]
#[rustc_const_unstable(feature = "transmutability", issue = "99571")]
impl const core::ops::Sub for Assume {
type Output = Assume;
fn sub(self, other_assumptions: Assume) -> Assume {
self.but_not(other_assumptions)
}
} }

View File

@ -3,6 +3,7 @@
//! provided indirectly through an abstraction. //! provided indirectly through an abstraction.
#![crate_type = "lib"] #![crate_type = "lib"]
#![feature(adt_const_params)]
#![feature(transmutability)] #![feature(transmutability)]
#![allow(dead_code, incomplete_features, non_camel_case_types)] #![allow(dead_code, incomplete_features, non_camel_case_types)]
@ -13,19 +14,13 @@ mod assert {
Src, Src,
Dst, Dst,
Context, Context,
const ASSUME_ALIGNMENT: bool, const ASSUME: std::mem::Assume,
const ASSUME_LIFETIMES: bool,
const ASSUME_VALIDITY: bool,
const ASSUME_VISIBILITY: bool,
>() >()
where where
Dst: BikeshedIntrinsicFrom< Dst: BikeshedIntrinsicFrom<
Src, Src,
Context, Context,
ASSUME_ALIGNMENT, ASSUME,
ASSUME_LIFETIMES,
ASSUME_VALIDITY,
ASSUME_VISIBILITY,
>, >,
{} {}
} }
@ -35,7 +30,7 @@ fn direct() {
#[repr(C)] struct Src; #[repr(C)] struct Src;
#[repr(C)] struct Dst; #[repr(C)] struct Dst;
assert::is_transmutable::<Src, Dst, Context, false, false, false, false>(); assert::is_transmutable::<Src, Dst, Context, { std::mem::Assume::NOTHING }>();
} }
fn via_const() { fn via_const() {
@ -45,7 +40,7 @@ fn via_const() {
const FALSE: bool = false; const FALSE: bool = false;
assert::is_transmutable::<Src, Dst, Context, FALSE, FALSE, FALSE, FALSE>(); assert::is_transmutable::<Src, Dst, Context, { std::mem::Assume::NOTHING }>();
} }
fn via_associated_const() { fn via_associated_const() {
@ -65,9 +60,13 @@ fn via_associated_const() {
Src, Src,
Dst, Dst,
Context, Context,
{Ty::FALSE}, {
{Ty::FALSE}, std::mem::Assume {
{Ty::FALSE}, alignment: {Ty::FALSE},
{Ty::FALSE} lifetimes: {Ty::FALSE},
safety: {Ty::FALSE},
validity: {Ty::FALSE},
}
}
>(); >();
} }

View File

@ -6,13 +6,13 @@
#![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::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn array_like<T, E, const N: usize>() pub fn array_like<T, E, const N: usize>()
where where
T: BikeshedIntrinsicFrom<[E; N], Context, false, false, false, true>, T: BikeshedIntrinsicFrom<[E; N], Context, { Assume::SAFETY }>,
[E; N]: BikeshedIntrinsicFrom<T, Context, false, false, false, true> [E; N]: BikeshedIntrinsicFrom<T, Context, { Assume::SAFETY }>
{} {}
} }

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::BikeshedIntrinsicFrom; use std::mem::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY.and(Assume::VALIDITY) }>
{} {}
} }

View File

@ -6,12 +6,17 @@
#![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::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> Dst: BikeshedIntrinsicFrom<Src, Context, {
Assume::ALIGNMENT
.and(Assume::LIFETIMES)
.and(Assume::SAFETY)
.and(Assume::VALIDITY)
}>
{} {}
} }

View File

@ -5,12 +5,17 @@
#![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::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> Dst: BikeshedIntrinsicFrom<Src, Context, {
Assume::ALIGNMENT
.and(Assume::LIFETIMES)
.and(Assume::SAFETY)
.and(Assume::VALIDITY)
}>
{} {}
} }

View File

@ -1,98 +1,134 @@
error[E0277]: `[String; 0]` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. error[E0277]: `[String; 0]` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:21:52 --> $DIR/should_require_well_defined_layout.rs:26:52
| |
LL | assert::is_maybe_transmutable::<repr_rust, ()>(); LL | assert::is_maybe_transmutable::<repr_rust, ()>();
| ^^ `[String; 0]` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. | ^^ `[String; 0]` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<[String; 0], assert::Context, true, true, true, true>` is not implemented for `()` = help: the trait `BikeshedIntrinsicFrom<[String; 0], assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `()`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES)
LL | | .and(Assume::SAFETY)
LL | | .and(Assume::VALIDITY)
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `u128` cannot be safely transmuted into `[String; 0]` in the defining scope of `assert::Context`. error[E0277]: `u128` cannot be safely transmuted into `[String; 0]` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:22:47 --> $DIR/should_require_well_defined_layout.rs:27:47
| |
LL | assert::is_maybe_transmutable::<u128, repr_rust>(); LL | assert::is_maybe_transmutable::<u128, repr_rust>();
| ^^^^^^^^^ `u128` cannot be safely transmuted into `[String; 0]` in the defining scope of `assert::Context`. | ^^^^^^^^^ `u128` cannot be safely transmuted into `[String; 0]` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, true, true, true, true>` is not implemented for `[String; 0]` = help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `[String; 0]`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES)
LL | | .and(Assume::SAFETY)
LL | | .and(Assume::VALIDITY)
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `[String; 1]` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. error[E0277]: `[String; 1]` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:27:52 --> $DIR/should_require_well_defined_layout.rs:32:52
| |
LL | assert::is_maybe_transmutable::<repr_rust, ()>(); LL | assert::is_maybe_transmutable::<repr_rust, ()>();
| ^^ `[String; 1]` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. | ^^ `[String; 1]` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<[String; 1], assert::Context, true, true, true, true>` is not implemented for `()` = help: the trait `BikeshedIntrinsicFrom<[String; 1], assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `()`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES)
LL | | .and(Assume::SAFETY)
LL | | .and(Assume::VALIDITY)
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `u128` cannot be safely transmuted into `[String; 1]` in the defining scope of `assert::Context`. error[E0277]: `u128` cannot be safely transmuted into `[String; 1]` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:28:47 --> $DIR/should_require_well_defined_layout.rs:33:47
| |
LL | assert::is_maybe_transmutable::<u128, repr_rust>(); LL | assert::is_maybe_transmutable::<u128, repr_rust>();
| ^^^^^^^^^ `u128` cannot be safely transmuted into `[String; 1]` in the defining scope of `assert::Context`. | ^^^^^^^^^ `u128` cannot be safely transmuted into `[String; 1]` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, true, true, true, true>` is not implemented for `[String; 1]` = help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `[String; 1]`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES)
LL | | .and(Assume::SAFETY)
LL | | .and(Assume::VALIDITY)
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `[String; 2]` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. error[E0277]: `[String; 2]` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:33:52 --> $DIR/should_require_well_defined_layout.rs:38:52
| |
LL | assert::is_maybe_transmutable::<repr_rust, ()>(); LL | assert::is_maybe_transmutable::<repr_rust, ()>();
| ^^ `[String; 2]` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. | ^^ `[String; 2]` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<[String; 2], assert::Context, true, true, true, true>` is not implemented for `()` = help: the trait `BikeshedIntrinsicFrom<[String; 2], assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `()`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES)
LL | | .and(Assume::SAFETY)
LL | | .and(Assume::VALIDITY)
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `u128` cannot be safely transmuted into `[String; 2]` in the defining scope of `assert::Context`. error[E0277]: `u128` cannot be safely transmuted into `[String; 2]` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:34:47 --> $DIR/should_require_well_defined_layout.rs:39:47
| |
LL | assert::is_maybe_transmutable::<u128, repr_rust>(); LL | assert::is_maybe_transmutable::<u128, repr_rust>();
| ^^^^^^^^^ `u128` cannot be safely transmuted into `[String; 2]` in the defining scope of `assert::Context`. | ^^^^^^^^^ `u128` cannot be safely transmuted into `[String; 2]` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, true, true, true, true>` is not implemented for `[String; 2]` = help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `[String; 2]`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES)
LL | | .and(Assume::SAFETY)
LL | | .and(Assume::VALIDITY)
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error: aborting due to 6 previous errors error: aborting due to 6 previous errors

View File

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

View File

@ -1,322 +1,462 @@
error[E0277]: `Zst` cannot be safely transmuted into `V0i8` in the defining scope of `n8::Context`. error[E0277]: `Zst` cannot be safely transmuted into `V0i8` in the defining scope of `n8::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:41:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:48:44
| |
LL | assert::is_transmutable::<Smaller, Current, Context>(); LL | assert::is_transmutable::<Smaller, Current, Context>();
| ^^^^^^^ `Zst` cannot be safely transmuted into `V0i8` in the defining scope of `n8::Context`. | ^^^^^^^ `Zst` cannot be safely transmuted into `V0i8` in the defining scope of `n8::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<Zst, n8::Context, true, true, true, true>` is not implemented for `V0i8` = help: the trait `BikeshedIntrinsicFrom<Zst, n8::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `V0i8`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `V0i8` cannot be safely transmuted into `u16` in the defining scope of `n8::Context`. error[E0277]: `V0i8` cannot be safely transmuted into `u16` in the defining scope of `n8::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:43:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:50:44
| |
LL | assert::is_transmutable::<Current, Larger, Context>(); LL | assert::is_transmutable::<Current, Larger, Context>();
| ^^^^^^ `V0i8` cannot be safely transmuted into `u16` in the defining scope of `n8::Context`. | ^^^^^^ `V0i8` cannot be safely transmuted into `u16` in the defining scope of `n8::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<V0i8, n8::Context, true, true, true, true>` is not implemented for `u16` = help: the trait `BikeshedIntrinsicFrom<V0i8, n8::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `u16`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `Zst` cannot be safely transmuted into `V0u8` in the defining scope of `n8::Context`. error[E0277]: `Zst` cannot be safely transmuted into `V0u8` in the defining scope of `n8::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:49:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:56:44
| |
LL | assert::is_transmutable::<Smaller, Current, Context>(); LL | assert::is_transmutable::<Smaller, Current, Context>();
| ^^^^^^^ `Zst` cannot be safely transmuted into `V0u8` in the defining scope of `n8::Context`. | ^^^^^^^ `Zst` cannot be safely transmuted into `V0u8` in the defining scope of `n8::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<Zst, n8::Context, true, true, true, true>` is not implemented for `V0u8` = help: the trait `BikeshedIntrinsicFrom<Zst, n8::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `V0u8`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `V0u8` cannot be safely transmuted into `u16` in the defining scope of `n8::Context`. error[E0277]: `V0u8` cannot be safely transmuted into `u16` in the defining scope of `n8::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:51:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:58:44
| |
LL | assert::is_transmutable::<Current, Larger, Context>(); LL | assert::is_transmutable::<Current, Larger, Context>();
| ^^^^^^ `V0u8` cannot be safely transmuted into `u16` in the defining scope of `n8::Context`. | ^^^^^^ `V0u8` cannot be safely transmuted into `u16` in the defining scope of `n8::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<V0u8, n8::Context, true, true, true, true>` is not implemented for `u16` = help: the trait `BikeshedIntrinsicFrom<V0u8, n8::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `u16`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `V0i16` in the defining scope of `n16::Context`. error[E0277]: `u8` cannot be safely transmuted into `V0i16` in the defining scope of `n16::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:65:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:72:44
| |
LL | assert::is_transmutable::<Smaller, Current, Context>(); LL | assert::is_transmutable::<Smaller, Current, Context>();
| ^^^^^^^ `u8` cannot be safely transmuted into `V0i16` in the defining scope of `n16::Context`. | ^^^^^^^ `u8` cannot be safely transmuted into `V0i16` in the defining scope of `n16::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u8, n16::Context, true, true, true, true>` is not implemented for `V0i16` = help: the trait `BikeshedIntrinsicFrom<u8, n16::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `V0i16`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `V0i16` cannot be safely transmuted into `u32` in the defining scope of `n16::Context`. error[E0277]: `V0i16` cannot be safely transmuted into `u32` in the defining scope of `n16::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:67:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:74:44
| |
LL | assert::is_transmutable::<Current, Larger, Context>(); LL | assert::is_transmutable::<Current, Larger, Context>();
| ^^^^^^ `V0i16` cannot be safely transmuted into `u32` in the defining scope of `n16::Context`. | ^^^^^^ `V0i16` cannot be safely transmuted into `u32` in the defining scope of `n16::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<V0i16, n16::Context, true, true, true, true>` is not implemented for `u32` = help: the trait `BikeshedIntrinsicFrom<V0i16, n16::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `u32`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `V0u16` in the defining scope of `n16::Context`. error[E0277]: `u8` cannot be safely transmuted into `V0u16` in the defining scope of `n16::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:73:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:80:44
| |
LL | assert::is_transmutable::<Smaller, Current, Context>(); LL | assert::is_transmutable::<Smaller, Current, Context>();
| ^^^^^^^ `u8` cannot be safely transmuted into `V0u16` in the defining scope of `n16::Context`. | ^^^^^^^ `u8` cannot be safely transmuted into `V0u16` in the defining scope of `n16::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u8, n16::Context, true, true, true, true>` is not implemented for `V0u16` = help: the trait `BikeshedIntrinsicFrom<u8, n16::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `V0u16`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `V0u16` cannot be safely transmuted into `u32` in the defining scope of `n16::Context`. error[E0277]: `V0u16` cannot be safely transmuted into `u32` in the defining scope of `n16::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:75:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:82:44
| |
LL | assert::is_transmutable::<Current, Larger, Context>(); LL | assert::is_transmutable::<Current, Larger, Context>();
| ^^^^^^ `V0u16` cannot be safely transmuted into `u32` in the defining scope of `n16::Context`. | ^^^^^^ `V0u16` cannot be safely transmuted into `u32` in the defining scope of `n16::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<V0u16, n16::Context, true, true, true, true>` is not implemented for `u32` = help: the trait `BikeshedIntrinsicFrom<V0u16, n16::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `u32`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `V0i32` in the defining scope of `n32::Context`. error[E0277]: `u16` cannot be safely transmuted into `V0i32` in the defining scope of `n32::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:89:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:96:44
| |
LL | assert::is_transmutable::<Smaller, Current, Context>(); LL | assert::is_transmutable::<Smaller, Current, Context>();
| ^^^^^^^ `u16` cannot be safely transmuted into `V0i32` in the defining scope of `n32::Context`. | ^^^^^^^ `u16` cannot be safely transmuted into `V0i32` in the defining scope of `n32::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u16, n32::Context, true, true, true, true>` is not implemented for `V0i32` = help: the trait `BikeshedIntrinsicFrom<u16, n32::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `V0i32`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `V0i32` cannot be safely transmuted into `u64` in the defining scope of `n32::Context`. error[E0277]: `V0i32` cannot be safely transmuted into `u64` in the defining scope of `n32::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:91:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:98:44
| |
LL | assert::is_transmutable::<Current, Larger, Context>(); LL | assert::is_transmutable::<Current, Larger, Context>();
| ^^^^^^ `V0i32` cannot be safely transmuted into `u64` in the defining scope of `n32::Context`. | ^^^^^^ `V0i32` cannot be safely transmuted into `u64` in the defining scope of `n32::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<V0i32, n32::Context, true, true, true, true>` is not implemented for `u64` = help: the trait `BikeshedIntrinsicFrom<V0i32, n32::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `u64`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `V0u32` in the defining scope of `n32::Context`. error[E0277]: `u16` cannot be safely transmuted into `V0u32` in the defining scope of `n32::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:97:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:104:44
| |
LL | assert::is_transmutable::<Smaller, Current, Context>(); LL | assert::is_transmutable::<Smaller, Current, Context>();
| ^^^^^^^ `u16` cannot be safely transmuted into `V0u32` in the defining scope of `n32::Context`. | ^^^^^^^ `u16` cannot be safely transmuted into `V0u32` in the defining scope of `n32::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u16, n32::Context, true, true, true, true>` is not implemented for `V0u32` = help: the trait `BikeshedIntrinsicFrom<u16, n32::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `V0u32`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `V0u32` cannot be safely transmuted into `u64` in the defining scope of `n32::Context`. error[E0277]: `V0u32` cannot be safely transmuted into `u64` in the defining scope of `n32::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:99:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:106:44
| |
LL | assert::is_transmutable::<Current, Larger, Context>(); LL | assert::is_transmutable::<Current, Larger, Context>();
| ^^^^^^ `V0u32` cannot be safely transmuted into `u64` in the defining scope of `n32::Context`. | ^^^^^^ `V0u32` cannot be safely transmuted into `u64` in the defining scope of `n32::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<V0u32, n32::Context, true, true, true, true>` is not implemented for `u64` = help: the trait `BikeshedIntrinsicFrom<V0u32, n32::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `u64`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `V0i64` in the defining scope of `n64::Context`. error[E0277]: `u32` cannot be safely transmuted into `V0i64` in the defining scope of `n64::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:113:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:120:44
| |
LL | assert::is_transmutable::<Smaller, Current, Context>(); LL | assert::is_transmutable::<Smaller, Current, Context>();
| ^^^^^^^ `u32` cannot be safely transmuted into `V0i64` in the defining scope of `n64::Context`. | ^^^^^^^ `u32` cannot be safely transmuted into `V0i64` in the defining scope of `n64::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u32, n64::Context, true, true, true, true>` is not implemented for `V0i64` = help: the trait `BikeshedIntrinsicFrom<u32, n64::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `V0i64`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `V0i64` cannot be safely transmuted into `u128` in the defining scope of `n64::Context`. error[E0277]: `V0i64` cannot be safely transmuted into `u128` in the defining scope of `n64::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:115:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:122:44
| |
LL | assert::is_transmutable::<Current, Larger, Context>(); LL | assert::is_transmutable::<Current, Larger, Context>();
| ^^^^^^ `V0i64` cannot be safely transmuted into `u128` in the defining scope of `n64::Context`. | ^^^^^^ `V0i64` cannot be safely transmuted into `u128` in the defining scope of `n64::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<V0i64, n64::Context, true, true, true, true>` is not implemented for `u128` = help: the trait `BikeshedIntrinsicFrom<V0i64, n64::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `u128`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `V0u64` in the defining scope of `n64::Context`. error[E0277]: `u32` cannot be safely transmuted into `V0u64` in the defining scope of `n64::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:121:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:128:44
| |
LL | assert::is_transmutable::<Smaller, Current, Context>(); LL | assert::is_transmutable::<Smaller, Current, Context>();
| ^^^^^^^ `u32` cannot be safely transmuted into `V0u64` in the defining scope of `n64::Context`. | ^^^^^^^ `u32` cannot be safely transmuted into `V0u64` in the defining scope of `n64::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u32, n64::Context, true, true, true, true>` is not implemented for `V0u64` = help: the trait `BikeshedIntrinsicFrom<u32, n64::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `V0u64`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `V0u64` cannot be safely transmuted into `u128` in the defining scope of `n64::Context`. error[E0277]: `V0u64` cannot be safely transmuted into `u128` in the defining scope of `n64::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:123:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:130:44
| |
LL | assert::is_transmutable::<Current, Larger, Context>(); LL | assert::is_transmutable::<Current, Larger, Context>();
| ^^^^^^ `V0u64` cannot be safely transmuted into `u128` in the defining scope of `n64::Context`. | ^^^^^^ `V0u64` cannot be safely transmuted into `u128` in the defining scope of `n64::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<V0u64, n64::Context, true, true, true, true>` is not implemented for `u128` = help: the trait `BikeshedIntrinsicFrom<V0u64, n64::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `u128`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `V0isize` in the defining scope of `nsize::Context`. error[E0277]: `u8` cannot be safely transmuted into `V0isize` in the defining scope of `nsize::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:137:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:144:44
| |
LL | assert::is_transmutable::<Smaller, Current, Context>(); LL | assert::is_transmutable::<Smaller, Current, Context>();
| ^^^^^^^ `u8` cannot be safely transmuted into `V0isize` in the defining scope of `nsize::Context`. | ^^^^^^^ `u8` cannot be safely transmuted into `V0isize` in the defining scope of `nsize::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u8, nsize::Context, true, true, true, true>` is not implemented for `V0isize` = help: the trait `BikeshedIntrinsicFrom<u8, nsize::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `V0isize`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `V0isize` cannot be safely transmuted into `[usize; 2]` in the defining scope of `nsize::Context`. error[E0277]: `V0isize` cannot be safely transmuted into `[usize; 2]` in the defining scope of `nsize::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:139:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:146:44
| |
LL | assert::is_transmutable::<Current, Larger, Context>(); LL | assert::is_transmutable::<Current, Larger, Context>();
| ^^^^^^ `V0isize` cannot be safely transmuted into `[usize; 2]` in the defining scope of `nsize::Context`. | ^^^^^^ `V0isize` cannot be safely transmuted into `[usize; 2]` in the defining scope of `nsize::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<V0isize, nsize::Context, true, true, true, true>` is not implemented for `[usize; 2]` = help: the trait `BikeshedIntrinsicFrom<V0isize, nsize::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `[usize; 2]`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `V0usize` in the defining scope of `nsize::Context`. error[E0277]: `u8` cannot be safely transmuted into `V0usize` in the defining scope of `nsize::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:145:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:152:44
| |
LL | assert::is_transmutable::<Smaller, Current, Context>(); LL | assert::is_transmutable::<Smaller, Current, Context>();
| ^^^^^^^ `u8` cannot be safely transmuted into `V0usize` in the defining scope of `nsize::Context`. | ^^^^^^^ `u8` cannot be safely transmuted into `V0usize` in the defining scope of `nsize::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u8, nsize::Context, true, true, true, true>` is not implemented for `V0usize` = help: the trait `BikeshedIntrinsicFrom<u8, nsize::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `V0usize`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error[E0277]: `V0usize` cannot be safely transmuted into `[usize; 2]` in the defining scope of `nsize::Context`. error[E0277]: `V0usize` cannot be safely transmuted into `[usize; 2]` in the defining scope of `nsize::Context`.
--> $DIR/primitive_reprs_should_have_correct_length.rs:147:44 --> $DIR/primitive_reprs_should_have_correct_length.rs:154:44
| |
LL | assert::is_transmutable::<Current, Larger, Context>(); LL | assert::is_transmutable::<Current, Larger, Context>();
| ^^^^^^ `V0usize` cannot be safely transmuted into `[usize; 2]` in the defining scope of `nsize::Context`. | ^^^^^^ `V0usize` cannot be safely transmuted into `[usize; 2]` in the defining scope of `nsize::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<V0usize, nsize::Context, true, true, true, true>` is not implemented for `[usize; 2]` = help: the trait `BikeshedIntrinsicFrom<V0usize, nsize::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `[usize; 2]`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14 --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error: aborting due to 20 previous errors error: aborting due to 20 previous errors

View File

@ -6,12 +6,19 @@
#![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::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> Dst: BikeshedIntrinsicFrom<Src, Context, {
Assume {
alignment: true,
lifetimes: true,
safety: true,
validity: true,
}
}>
{} {}
} }

View File

@ -1,98 +1,140 @@
error[E0277]: `void::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. error[E0277]: `void::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:21:52 --> $DIR/should_require_well_defined_layout.rs:28:52
| |
LL | assert::is_maybe_transmutable::<repr_rust, ()>(); LL | assert::is_maybe_transmutable::<repr_rust, ()>();
| ^^ `void::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. | ^^ `void::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<void::repr_rust, assert::Context, true, true, true, true>` is not implemented for `()` = help: the trait `BikeshedIntrinsicFrom<void::repr_rust, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `()`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:14:14 --> $DIR/should_require_well_defined_layout.rs:14:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `u128` cannot be safely transmuted into `void::repr_rust` in the defining scope of `assert::Context`. error[E0277]: `u128` cannot be safely transmuted into `void::repr_rust` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:22:47 --> $DIR/should_require_well_defined_layout.rs:29:47
| |
LL | assert::is_maybe_transmutable::<u128, repr_rust>(); LL | assert::is_maybe_transmutable::<u128, repr_rust>();
| ^^^^^^^^^ `u128` cannot be safely transmuted into `void::repr_rust` in the defining scope of `assert::Context`. | ^^^^^^^^^ `u128` cannot be safely transmuted into `void::repr_rust` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, true, true, true, true>` is not implemented for `void::repr_rust` = help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `void::repr_rust`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:14:14 --> $DIR/should_require_well_defined_layout.rs:14:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `singleton::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. error[E0277]: `singleton::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:27:52 --> $DIR/should_require_well_defined_layout.rs:34:52
| |
LL | assert::is_maybe_transmutable::<repr_rust, ()>(); LL | assert::is_maybe_transmutable::<repr_rust, ()>();
| ^^ `singleton::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. | ^^ `singleton::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<singleton::repr_rust, assert::Context, true, true, true, true>` is not implemented for `()` = help: the trait `BikeshedIntrinsicFrom<singleton::repr_rust, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `()`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:14:14 --> $DIR/should_require_well_defined_layout.rs:14:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `u128` cannot be safely transmuted into `singleton::repr_rust` in the defining scope of `assert::Context`. error[E0277]: `u128` cannot be safely transmuted into `singleton::repr_rust` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:28:47 --> $DIR/should_require_well_defined_layout.rs:35:47
| |
LL | assert::is_maybe_transmutable::<u128, repr_rust>(); LL | assert::is_maybe_transmutable::<u128, repr_rust>();
| ^^^^^^^^^ `u128` cannot be safely transmuted into `singleton::repr_rust` in the defining scope of `assert::Context`. | ^^^^^^^^^ `u128` cannot be safely transmuted into `singleton::repr_rust` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, true, true, true, true>` is not implemented for `singleton::repr_rust` = help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `singleton::repr_rust`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:14:14 --> $DIR/should_require_well_defined_layout.rs:14:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `duplex::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. error[E0277]: `duplex::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:33:52 --> $DIR/should_require_well_defined_layout.rs:40:52
| |
LL | assert::is_maybe_transmutable::<repr_rust, ()>(); LL | assert::is_maybe_transmutable::<repr_rust, ()>();
| ^^ `duplex::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. | ^^ `duplex::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<duplex::repr_rust, assert::Context, true, true, true, true>` is not implemented for `()` = help: the trait `BikeshedIntrinsicFrom<duplex::repr_rust, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `()`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:14:14 --> $DIR/should_require_well_defined_layout.rs:14:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `u128` cannot be safely transmuted into `duplex::repr_rust` in the defining scope of `assert::Context`. error[E0277]: `u128` cannot be safely transmuted into `duplex::repr_rust` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:34:47 --> $DIR/should_require_well_defined_layout.rs:41:47
| |
LL | assert::is_maybe_transmutable::<u128, repr_rust>(); LL | assert::is_maybe_transmutable::<u128, repr_rust>();
| ^^^^^^^^^ `u128` cannot be safely transmuted into `duplex::repr_rust` in the defining scope of `assert::Context`. | ^^^^^^^^^ `u128` cannot be safely transmuted into `duplex::repr_rust` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, true, true, true, true>` is not implemented for `duplex::repr_rust` = help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `duplex::repr_rust`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:14:14 --> $DIR/should_require_well_defined_layout.rs:14:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error: aborting due to 6 previous errors error: aborting due to 6 previous errors

View File

@ -7,12 +7,17 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> Dst: BikeshedIntrinsicFrom<Src, Context, {
Assume::ALIGNMENT
.and(Assume::LIFETIMES)
.and(Assume::SAFETY)
.and(Assume::VALIDITY)
}>
{} {}
} }

View File

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

View File

@ -1,18 +1,24 @@
error[E0277]: `Src` cannot be safely transmuted into `Dst` in the defining scope of `should_pad_variants::Context`. error[E0277]: `Src` cannot be safely transmuted into `Dst` in the defining scope of `should_pad_variants::Context`.
--> $DIR/should_pad_variants.rs:39:36 --> $DIR/should_pad_variants.rs:44:36
| |
LL | assert::is_transmutable::<Src, Dst, Context>(); LL | assert::is_transmutable::<Src, Dst, Context>();
| ^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `should_pad_variants::Context`. | ^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `should_pad_variants::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<Src, should_pad_variants::Context, true, true, true, true>` is not implemented for `Dst` = help: the trait `BikeshedIntrinsicFrom<Src, should_pad_variants::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `Dst`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/should_pad_variants.rs:13:14 --> $DIR/should_pad_variants.rs:13:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES)
LL | | .and(Assume::SAFETY)
LL | | .and(Assume::VALIDITY)
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error: aborting due to previous error error: aborting due to previous error

View File

@ -7,12 +7,17 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> Dst: BikeshedIntrinsicFrom<Src, Context, {
Assume::ALIGNMENT
.and(Assume::LIFETIMES)
.and(Assume::SAFETY)
.and(Assume::VALIDITY)
}>
{} {}
} }

View File

@ -1,18 +1,24 @@
error[E0277]: `Src` cannot be safely transmuted into `Unexpected` in the defining scope of `assert::Context`. error[E0277]: `Src` cannot be safely transmuted into `Unexpected` in the defining scope of `assert::Context`.
--> $DIR/should_respect_endianness.rs:32:36 --> $DIR/should_respect_endianness.rs:37:36
| |
LL | assert::is_transmutable::<Src, Unexpected>(); LL | assert::is_transmutable::<Src, Unexpected>();
| ^^^^^^^^^^ `Src` cannot be safely transmuted into `Unexpected` in the defining scope of `assert::Context`. | ^^^^^^^^^^ `Src` cannot be safely transmuted into `Unexpected` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<Src, assert::Context, true, true, true, true>` is not implemented for `Unexpected` = help: the trait `BikeshedIntrinsicFrom<Src, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `Unexpected`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/should_respect_endianness.rs:15:14 --> $DIR/should_respect_endianness.rs:15:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES)
LL | | .and(Assume::SAFETY)
LL | | .and(Assume::VALIDITY)
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error: aborting due to previous error error: aborting due to previous error

View File

@ -10,7 +10,7 @@ mod assert {
pub fn is_transmutable<Src, Dst, Context>() pub fn is_transmutable<Src, Dst, Context>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, false> Dst: BikeshedIntrinsicFrom<Src, Context>
{} {}
} }

View File

@ -10,7 +10,7 @@ mod assert {
pub fn is_transmutable<Src, Dst, Context>() pub fn is_transmutable<Src, Dst, Context>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, false> Dst: BikeshedIntrinsicFrom<Src, Context>
{} {}
} }

View File

@ -10,7 +10,7 @@ mod assert {
pub fn is_transmutable<Src, Dst, Context>() pub fn is_transmutable<Src, Dst, Context>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, false> Dst: BikeshedIntrinsicFrom<Src, Context>
{} {}
} }

View File

@ -2,11 +2,13 @@
//! provided. //! provided.
#![crate_type = "lib"] #![crate_type = "lib"]
#![feature(adt_const_params)]
#![feature(generic_const_exprs)]
#![feature(transmutability)] #![feature(transmutability)]
#![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::{Assume, BikeshedIntrinsicFrom};
pub fn is_transmutable< pub fn is_transmutable<
Src, Src,
@ -14,19 +16,34 @@ mod assert {
Context, Context,
const ASSUME_ALIGNMENT: bool, const ASSUME_ALIGNMENT: bool,
const ASSUME_LIFETIMES: bool, const ASSUME_LIFETIMES: bool,
const ASSUME_SAFETY: bool,
const ASSUME_VALIDITY: bool, const ASSUME_VALIDITY: bool,
const ASSUME_VISIBILITY: bool,
>() >()
where where
Dst: BikeshedIntrinsicFrom< Dst: BikeshedIntrinsicFrom<
Src, Src,
Context, Context,
ASSUME_ALIGNMENT, { from_options(ASSUME_ALIGNMENT, ASSUME_LIFETIMES, ASSUME_SAFETY, ASSUME_VALIDITY) }
ASSUME_LIFETIMES, //~^ ERROR E0080
ASSUME_VALIDITY, //~| ERROR E0080
ASSUME_VISIBILITY, //~| ERROR E0080
//~| ERROR E0080
>, >,
{} {}
const fn from_options(
alignment: bool,
lifetimes: bool,
safety: bool,
validity: bool,
) -> Assume {
Assume {
alignment,
lifetimes,
safety,
validity,
}
}
} }
fn test() { fn test() {

View File

@ -1,27 +1,52 @@
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/wrong-type-assume.rs:36:51 --> $DIR/wrong-type-assume.rs:53:51
| |
LL | assert::is_transmutable::<Src, Dst, Context, {0u8}, false, false, false>(); LL | assert::is_transmutable::<Src, Dst, Context, {0u8}, false, false, false>();
| ^^^ expected `bool`, found `u8` | ^^^ expected `bool`, found `u8`
error[E0080]: evaluation of `assert::is_transmutable::<test::Src, test::Dst, test::Context, {0u8}, false, false, false>::{constant#0}` failed
--> $DIR/wrong-type-assume.rs:26:15
|
LL | { from_options(ASSUME_ALIGNMENT, ASSUME_LIFETIMES, ASSUME_SAFETY, ASSUME_VALIDITY) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ referenced constant has errors
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/wrong-type-assume.rs:37:58 --> $DIR/wrong-type-assume.rs:54:58
| |
LL | assert::is_transmutable::<Src, Dst, Context, false, {0u8}, false, false>(); LL | assert::is_transmutable::<Src, Dst, Context, false, {0u8}, false, false>();
| ^^^ expected `bool`, found `u8` | ^^^ expected `bool`, found `u8`
error[E0080]: evaluation of `assert::is_transmutable::<test::Src, test::Dst, test::Context, false, {0u8}, false, false>::{constant#0}` failed
--> $DIR/wrong-type-assume.rs:26:15
|
LL | { from_options(ASSUME_ALIGNMENT, ASSUME_LIFETIMES, ASSUME_SAFETY, ASSUME_VALIDITY) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ referenced constant has errors
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/wrong-type-assume.rs:38:65 --> $DIR/wrong-type-assume.rs:55:65
| |
LL | assert::is_transmutable::<Src, Dst, Context, false, false, {0u8}, false>(); LL | assert::is_transmutable::<Src, Dst, Context, false, false, {0u8}, false>();
| ^^^ expected `bool`, found `u8` | ^^^ expected `bool`, found `u8`
error[E0080]: evaluation of `assert::is_transmutable::<test::Src, test::Dst, test::Context, false, false, {0u8}, false>::{constant#0}` failed
--> $DIR/wrong-type-assume.rs:26:15
|
LL | { from_options(ASSUME_ALIGNMENT, ASSUME_LIFETIMES, ASSUME_SAFETY, ASSUME_VALIDITY) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ referenced constant has errors
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/wrong-type-assume.rs:39:72 --> $DIR/wrong-type-assume.rs:56:72
| |
LL | assert::is_transmutable::<Src, Dst, Context, false, false, false, {0u8}>(); LL | assert::is_transmutable::<Src, Dst, Context, false, false, false, {0u8}>();
| ^^^ expected `bool`, found `u8` | ^^^ expected `bool`, found `u8`
error: aborting due to 4 previous errors error[E0080]: evaluation of `assert::is_transmutable::<test::Src, test::Dst, test::Context, false, false, false, {0u8}>::{constant#0}` failed
--> $DIR/wrong-type-assume.rs:26:15
|
LL | { from_options(ASSUME_ALIGNMENT, ASSUME_LIFETIMES, ASSUME_SAFETY, ASSUME_VALIDITY) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ referenced constant has errors
For more information about this error, try `rustc --explain E0308`. error: aborting due to 8 previous errors
Some errors have detailed explanations: E0080, E0308.
For more information about an error, try `rustc --explain E0080`.

View File

@ -4,17 +4,17 @@
#![allow(incomplete_features)] #![allow(incomplete_features)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, true> Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
{} {}
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, true, true> Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY.and(Assume::VALIDITY) }>
{} {}
} }

View File

@ -4,15 +4,15 @@ error[E0277]: `u8` cannot be safely transmuted into `bool` in the defining scope
LL | assert::is_transmutable::<u8, bool>(); LL | assert::is_transmutable::<u8, bool>();
| ^^^^ `u8` cannot be safely transmuted into `bool` in the defining scope of `assert::Context`. | ^^^^ `u8` cannot be safely transmuted into `bool` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, false, false, false, true>` is not implemented for `bool` = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: true, validity: false }>` is not implemented for `bool`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/bool.rs:12:14 --> $DIR/bool.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error: aborting due to previous error error: aborting due to previous error

View File

@ -9,7 +9,7 @@ mod assert {
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, false> Dst: BikeshedIntrinsicFrom<Src, Context>
{} {}
} }

File diff suppressed because it is too large Load Diff

View File

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

View File

@ -1,18 +1,24 @@
error[E0277]: `()` cannot be safely transmuted into `u8` in the defining scope of `should_have_correct_size::Context`. error[E0277]: `()` cannot be safely transmuted into `u8` in the defining scope of `should_have_correct_size::Context`.
--> $DIR/unit.rs:23:35 --> $DIR/unit.rs:28:35
| |
LL | assert::is_transmutable::<(), u8, Context>(); LL | assert::is_transmutable::<(), u8, Context>();
| ^^ `()` cannot be safely transmuted into `u8` in the defining scope of `should_have_correct_size::Context`. | ^^ `()` cannot be safely transmuted into `u8` in the defining scope of `should_have_correct_size::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<(), should_have_correct_size::Context, true, true, true, true>` is not implemented for `u8` = help: the trait `BikeshedIntrinsicFrom<(), should_have_correct_size::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `u8`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/unit.rs:12:14 --> $DIR/unit.rs:12:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES)
LL | | .and(Assume::SAFETY)
LL | | .and(Assume::VALIDITY)
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error: aborting due to previous error error: aborting due to previous error

View File

@ -5,12 +5,19 @@
#![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::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> Dst: BikeshedIntrinsicFrom<Src, Context, {
Assume {
alignment: true,
lifetimes: true,
safety: true,
validity: true,
}
}>
{} {}
} }

View File

@ -1,18 +1,25 @@
error[E0277]: `&'static Unit` cannot be safely transmuted into `&'static Unit` in the defining scope of `assert::Context`. error[E0277]: `&'static Unit` cannot be safely transmuted into `&'static Unit` in the defining scope of `assert::Context`.
--> $DIR/references.rs:19:52 --> $DIR/references.rs:26:52
| |
LL | assert::is_maybe_transmutable::<&'static Unit, &'static Unit>(); LL | assert::is_maybe_transmutable::<&'static Unit, &'static Unit>();
| ^^^^^^^^^^^^^ `&'static Unit` cannot be safely transmuted into `&'static Unit` in the defining scope of `assert::Context`. | ^^^^^^^^^^^^^ `&'static Unit` cannot be safely transmuted into `&'static Unit` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<&'static Unit, assert::Context, true, true, true, true>` is not implemented for `&'static Unit` = help: the trait `BikeshedIntrinsicFrom<&'static Unit, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `&'static Unit`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/references.rs:13:14 --> $DIR/references.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error: aborting due to previous error error: aborting due to previous error

View File

@ -6,12 +6,19 @@
#![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::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> Dst: BikeshedIntrinsicFrom<Src, Context, {
Assume {
alignment: true,
lifetimes: true,
safety: true,
validity: true,
}
}>
{} {}
} }

View File

@ -6,12 +6,19 @@
#![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::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> Dst: BikeshedIntrinsicFrom<Src, Context, {
Assume {
alignment: true,
lifetimes: true,
safety: true,
validity: true,
}
}>
{} {}
} }

View File

@ -5,12 +5,19 @@
#![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::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> Dst: BikeshedIntrinsicFrom<Src, Context, {
Assume {
alignment: true,
lifetimes: true,
safety: true,
validity: true,
}
}>
{} {}
} }

View File

@ -1,194 +1,278 @@
error[E0277]: `should_reject_repr_rust::unit::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. error[E0277]: `should_reject_repr_rust::unit::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:21:52 --> $DIR/should_require_well_defined_layout.rs:28:52
| |
LL | assert::is_maybe_transmutable::<repr_rust, ()>(); LL | assert::is_maybe_transmutable::<repr_rust, ()>();
| ^^ `should_reject_repr_rust::unit::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. | ^^ `should_reject_repr_rust::unit::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<should_reject_repr_rust::unit::repr_rust, assert::Context, true, true, true, true>` is not implemented for `()` = help: the trait `BikeshedIntrinsicFrom<should_reject_repr_rust::unit::repr_rust, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `()`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `u128` cannot be safely transmuted into `should_reject_repr_rust::unit::repr_rust` in the defining scope of `assert::Context`. error[E0277]: `u128` cannot be safely transmuted into `should_reject_repr_rust::unit::repr_rust` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:22:47 --> $DIR/should_require_well_defined_layout.rs:29:47
| |
LL | assert::is_maybe_transmutable::<u128, repr_rust>(); LL | assert::is_maybe_transmutable::<u128, repr_rust>();
| ^^^^^^^^^ `u128` cannot be safely transmuted into `should_reject_repr_rust::unit::repr_rust` in the defining scope of `assert::Context`. | ^^^^^^^^^ `u128` cannot be safely transmuted into `should_reject_repr_rust::unit::repr_rust` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, true, true, true, true>` is not implemented for `should_reject_repr_rust::unit::repr_rust` = help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `should_reject_repr_rust::unit::repr_rust`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `should_reject_repr_rust::tuple::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. error[E0277]: `should_reject_repr_rust::tuple::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:27:52 --> $DIR/should_require_well_defined_layout.rs:34:52
| |
LL | assert::is_maybe_transmutable::<repr_rust, ()>(); LL | assert::is_maybe_transmutable::<repr_rust, ()>();
| ^^ `should_reject_repr_rust::tuple::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. | ^^ `should_reject_repr_rust::tuple::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<should_reject_repr_rust::tuple::repr_rust, assert::Context, true, true, true, true>` is not implemented for `()` = help: the trait `BikeshedIntrinsicFrom<should_reject_repr_rust::tuple::repr_rust, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `()`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `u128` cannot be safely transmuted into `should_reject_repr_rust::tuple::repr_rust` in the defining scope of `assert::Context`. error[E0277]: `u128` cannot be safely transmuted into `should_reject_repr_rust::tuple::repr_rust` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:28:47 --> $DIR/should_require_well_defined_layout.rs:35:47
| |
LL | assert::is_maybe_transmutable::<u128, repr_rust>(); LL | assert::is_maybe_transmutable::<u128, repr_rust>();
| ^^^^^^^^^ `u128` cannot be safely transmuted into `should_reject_repr_rust::tuple::repr_rust` in the defining scope of `assert::Context`. | ^^^^^^^^^ `u128` cannot be safely transmuted into `should_reject_repr_rust::tuple::repr_rust` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, true, true, true, true>` is not implemented for `should_reject_repr_rust::tuple::repr_rust` = help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `should_reject_repr_rust::tuple::repr_rust`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `should_reject_repr_rust::braces::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. error[E0277]: `should_reject_repr_rust::braces::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:33:52 --> $DIR/should_require_well_defined_layout.rs:40:52
| |
LL | assert::is_maybe_transmutable::<repr_rust, ()>(); LL | assert::is_maybe_transmutable::<repr_rust, ()>();
| ^^ `should_reject_repr_rust::braces::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. | ^^ `should_reject_repr_rust::braces::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<should_reject_repr_rust::braces::repr_rust, assert::Context, true, true, true, true>` is not implemented for `()` = help: the trait `BikeshedIntrinsicFrom<should_reject_repr_rust::braces::repr_rust, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `()`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `u128` cannot be safely transmuted into `should_reject_repr_rust::braces::repr_rust` in the defining scope of `assert::Context`. error[E0277]: `u128` cannot be safely transmuted into `should_reject_repr_rust::braces::repr_rust` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:34:47 --> $DIR/should_require_well_defined_layout.rs:41:47
| |
LL | assert::is_maybe_transmutable::<u128, repr_rust>(); LL | assert::is_maybe_transmutable::<u128, repr_rust>();
| ^^^^^^^^^ `u128` cannot be safely transmuted into `should_reject_repr_rust::braces::repr_rust` in the defining scope of `assert::Context`. | ^^^^^^^^^ `u128` cannot be safely transmuted into `should_reject_repr_rust::braces::repr_rust` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, true, true, true, true>` is not implemented for `should_reject_repr_rust::braces::repr_rust` = help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `should_reject_repr_rust::braces::repr_rust`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `aligned::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. error[E0277]: `aligned::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:39:52 --> $DIR/should_require_well_defined_layout.rs:46:52
| |
LL | assert::is_maybe_transmutable::<repr_rust, ()>(); LL | assert::is_maybe_transmutable::<repr_rust, ()>();
| ^^ `aligned::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. | ^^ `aligned::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<aligned::repr_rust, assert::Context, true, true, true, true>` is not implemented for `()` = help: the trait `BikeshedIntrinsicFrom<aligned::repr_rust, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `()`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `u128` cannot be safely transmuted into `aligned::repr_rust` in the defining scope of `assert::Context`. error[E0277]: `u128` cannot be safely transmuted into `aligned::repr_rust` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:40:47 --> $DIR/should_require_well_defined_layout.rs:47:47
| |
LL | assert::is_maybe_transmutable::<u128, repr_rust>(); LL | assert::is_maybe_transmutable::<u128, repr_rust>();
| ^^^^^^^^^ `u128` cannot be safely transmuted into `aligned::repr_rust` in the defining scope of `assert::Context`. | ^^^^^^^^^ `u128` cannot be safely transmuted into `aligned::repr_rust` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, true, true, true, true>` is not implemented for `aligned::repr_rust` = help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `aligned::repr_rust`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `packed::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. error[E0277]: `packed::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:45:52 --> $DIR/should_require_well_defined_layout.rs:52:52
| |
LL | assert::is_maybe_transmutable::<repr_rust, ()>(); LL | assert::is_maybe_transmutable::<repr_rust, ()>();
| ^^ `packed::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. | ^^ `packed::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<packed::repr_rust, assert::Context, true, true, true, true>` is not implemented for `()` = help: the trait `BikeshedIntrinsicFrom<packed::repr_rust, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `()`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `u128` cannot be safely transmuted into `packed::repr_rust` in the defining scope of `assert::Context`. error[E0277]: `u128` cannot be safely transmuted into `packed::repr_rust` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:46:47 --> $DIR/should_require_well_defined_layout.rs:53:47
| |
LL | assert::is_maybe_transmutable::<u128, repr_rust>(); LL | assert::is_maybe_transmutable::<u128, repr_rust>();
| ^^^^^^^^^ `u128` cannot be safely transmuted into `packed::repr_rust` in the defining scope of `assert::Context`. | ^^^^^^^^^ `u128` cannot be safely transmuted into `packed::repr_rust` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, true, true, true, true>` is not implemented for `packed::repr_rust` = help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `packed::repr_rust`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `nested::repr_c` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. error[E0277]: `nested::repr_c` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:52:49 --> $DIR/should_require_well_defined_layout.rs:59:49
| |
LL | assert::is_maybe_transmutable::<repr_c, ()>(); LL | assert::is_maybe_transmutable::<repr_c, ()>();
| ^^ `nested::repr_c` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. | ^^ `nested::repr_c` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<nested::repr_c, assert::Context, true, true, true, true>` is not implemented for `()` = help: the trait `BikeshedIntrinsicFrom<nested::repr_c, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `()`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `u128` cannot be safely transmuted into `nested::repr_c` in the defining scope of `assert::Context`. error[E0277]: `u128` cannot be safely transmuted into `nested::repr_c` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:53:47 --> $DIR/should_require_well_defined_layout.rs:60:47
| |
LL | assert::is_maybe_transmutable::<u128, repr_c>(); LL | assert::is_maybe_transmutable::<u128, repr_c>();
| ^^^^^^ `u128` cannot be safely transmuted into `nested::repr_c` in the defining scope of `assert::Context`. | ^^^^^^ `u128` cannot be safely transmuted into `nested::repr_c` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, true, true, true, true>` is not implemented for `nested::repr_c` = help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `nested::repr_c`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error: aborting due to 12 previous errors error: aborting due to 12 previous errors

View File

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

View File

@ -7,12 +7,12 @@
#![allow(incomplete_features)] #![allow(incomplete_features)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, true> Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
{} {}
} }

View File

@ -6,12 +6,19 @@
#![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::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> Dst: BikeshedIntrinsicFrom<Src, Context, {
Assume {
alignment: true,
lifetimes: true,
safety: true,
validity: true,
}
}>
{} {}
} }

View File

@ -6,12 +6,19 @@
#![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::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> Dst: BikeshedIntrinsicFrom<Src, Context, {
Assume {
alignment: true,
lifetimes: true,
safety: true,
validity: true,
}
}>
{} {}
} }

View File

@ -5,12 +5,19 @@
#![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::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> Dst: BikeshedIntrinsicFrom<Src, Context, {
Assume {
alignment: true,
lifetimes: true,
safety: true,
validity: true,
}
}>
{} {}
} }

View File

@ -1,34 +1,48 @@
error[E0277]: `should_reject_repr_rust::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. error[E0277]: `should_reject_repr_rust::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:23:48 --> $DIR/should_require_well_defined_layout.rs:30:48
| |
LL | assert::is_maybe_transmutable::<repr_rust, ()>(); LL | assert::is_maybe_transmutable::<repr_rust, ()>();
| ^^ `should_reject_repr_rust::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`. | ^^ `should_reject_repr_rust::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<should_reject_repr_rust::repr_rust, assert::Context, true, true, true, true>` is not implemented for `()` = help: the trait `BikeshedIntrinsicFrom<should_reject_repr_rust::repr_rust, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `()`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error[E0277]: `u128` cannot be safely transmuted into `should_reject_repr_rust::repr_rust` in the defining scope of `assert::Context`. error[E0277]: `u128` cannot be safely transmuted into `should_reject_repr_rust::repr_rust` in the defining scope of `assert::Context`.
--> $DIR/should_require_well_defined_layout.rs:24:43 --> $DIR/should_require_well_defined_layout.rs:31:43
| |
LL | assert::is_maybe_transmutable::<u128, repr_rust>(); LL | assert::is_maybe_transmutable::<u128, repr_rust>();
| ^^^^^^^^^ `u128` cannot be safely transmuted into `should_reject_repr_rust::repr_rust` in the defining scope of `assert::Context`. | ^^^^^^^^^ `u128` cannot be safely transmuted into `should_reject_repr_rust::repr_rust` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, true, true, true, true>` is not implemented for `should_reject_repr_rust::repr_rust` = help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `should_reject_repr_rust::repr_rust`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_require_well_defined_layout.rs:13:14 --> $DIR/should_require_well_defined_layout.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ______________^
LL | | Assume {
LL | | alignment: true,
LL | | lifetimes: true,
... |
LL | | }
LL | | }>
| |__________^ required by this bound in `is_maybe_transmutable`
error: aborting due to 2 previous errors error: aborting due to 2 previous errors

View File

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

View File

@ -1,18 +1,24 @@
error[E0277]: `Src` cannot be safely transmuted into `Dst` in the defining scope of `should_pad_variants::Context`. error[E0277]: `Src` cannot be safely transmuted into `Dst` in the defining scope of `should_pad_variants::Context`.
--> $DIR/should_pad_variants.rs:39:36 --> $DIR/should_pad_variants.rs:44:36
| |
LL | assert::is_transmutable::<Src, Dst, Context>(); LL | assert::is_transmutable::<Src, Dst, Context>();
| ^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `should_pad_variants::Context`. | ^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `should_pad_variants::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<Src, should_pad_variants::Context, true, true, true, true>` is not implemented for `Dst` = help: the trait `BikeshedIntrinsicFrom<Src, should_pad_variants::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `Dst`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/should_pad_variants.rs:13:14 --> $DIR/should_pad_variants.rs:13:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, true, true, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ______________^
LL | | Assume::ALIGNMENT
LL | | .and(Assume::LIFETIMES)
LL | | .and(Assume::SAFETY)
LL | | .and(Assume::VALIDITY)
LL | | }>
| |__________^ required by this bound in `is_transmutable`
error: aborting due to previous error error: aborting due to previous error

View File

@ -7,13 +7,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::BikeshedIntrinsicFrom; use std::mem::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, true, true> Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY.and(Assume::VALIDITY) }>
// validity IS assumed --------------------------------^^^^
{} {}
} }

View File

@ -5,12 +5,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::BikeshedIntrinsicFrom; use std::mem::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, true> Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
{} {}
} }

View File

@ -4,15 +4,15 @@ error[E0277]: `Superset` cannot be safely transmuted into `Subset` in the defini
LL | assert::is_transmutable::<Superset, Subset>(); LL | assert::is_transmutable::<Superset, Subset>();
| ^^^^^^ `Superset` cannot be safely transmuted into `Subset` in the defining scope of `assert::Context`. | ^^^^^^ `Superset` cannot be safely transmuted into `Subset` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<Superset, assert::Context, false, false, false, true>` is not implemented for `Subset` = help: the trait `BikeshedIntrinsicFrom<Superset, assert::Context, Assume { alignment: false, lifetimes: false, safety: true, validity: false }>` is not implemented for `Subset`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/should_reject_contraction.rs:13:14 --> $DIR/should_reject_contraction.rs:13:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error: aborting due to previous error error: aborting due to previous error

View File

@ -5,13 +5,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::BikeshedIntrinsicFrom; use std::mem::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_maybe_transmutable<Src, Dst>() pub fn is_maybe_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, true, true> Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY.and(Assume::VALIDITY) }>
// validity IS assumed --------------------------------^^^^
{} {}
} }

View File

@ -1,34 +1,34 @@
error[E0277]: `A` cannot be safely transmuted into `B` in the defining scope of `assert::Context`. error[E0277]: `A` cannot be safely transmuted into `B` in the defining scope of `assert::Context`.
--> $DIR/should_reject_disjoint.rs:34:40 --> $DIR/should_reject_disjoint.rs:33:40
| |
LL | assert::is_maybe_transmutable::<A, B>(); LL | assert::is_maybe_transmutable::<A, B>();
| ^ `A` cannot be safely transmuted into `B` in the defining scope of `assert::Context`. | ^ `A` cannot be safely transmuted into `B` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<A, assert::Context, false, false, true, true>` is not implemented for `B` = help: the trait `BikeshedIntrinsicFrom<A, assert::Context, Assume { alignment: false, lifetimes: false, safety: true, validity: true }>` is not implemented for `B`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_reject_disjoint.rs:13:14 --> $DIR/should_reject_disjoint.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, false, false, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY.and(Assume::VALIDITY) }>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
error[E0277]: `B` cannot be safely transmuted into `A` in the defining scope of `assert::Context`. error[E0277]: `B` cannot be safely transmuted into `A` in the defining scope of `assert::Context`.
--> $DIR/should_reject_disjoint.rs:35:40 --> $DIR/should_reject_disjoint.rs:34:40
| |
LL | assert::is_maybe_transmutable::<B, A>(); LL | assert::is_maybe_transmutable::<B, A>();
| ^ `B` cannot be safely transmuted into `A` in the defining scope of `assert::Context`. | ^ `B` cannot be safely transmuted into `A` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<B, assert::Context, false, false, true, true>` is not implemented for `A` = help: the trait `BikeshedIntrinsicFrom<B, assert::Context, Assume { alignment: false, lifetimes: false, safety: true, validity: true }>` is not implemented for `A`
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/should_reject_disjoint.rs:13:14 --> $DIR/should_reject_disjoint.rs:13:14
| |
LL | pub fn is_maybe_transmutable<Src, Dst>() LL | pub fn is_maybe_transmutable<Src, Dst>()
| --------------------- required by a bound in this | --------------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, false, false, true, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY.and(Assume::VALIDITY) }>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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

View File

@ -6,13 +6,13 @@
#![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::{Assume, BikeshedIntrinsicFrom};
pub struct Context; pub struct Context;
pub fn is_transmutable<Src, Dst>() pub fn is_transmutable<Src, Dst>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, true> Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
// validity is NOT assumed ----------------------------^^^^^ // validity is NOT assumed --------------^^^^^^^^^^^^^^^^^^
{} {}
} }

View File

@ -4,15 +4,15 @@ error[E0277]: `A` cannot be safely transmuted into `B` in the defining scope of
LL | assert::is_transmutable::<A, B>(); LL | assert::is_transmutable::<A, B>();
| ^ `A` cannot be safely transmuted into `B` in the defining scope of `assert::Context`. | ^ `A` cannot be safely transmuted into `B` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<A, assert::Context, false, false, false, true>` is not implemented for `B` = help: the trait `BikeshedIntrinsicFrom<A, assert::Context, Assume { alignment: false, lifetimes: false, safety: true, validity: false }>` is not implemented for `B`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/should_reject_intersecting.rs:14:14 --> $DIR/should_reject_intersecting.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `B` cannot be safely transmuted into `A` in the defining scope of `assert::Context`. error[E0277]: `B` cannot be safely transmuted into `A` in the defining scope of `assert::Context`.
--> $DIR/should_reject_intersecting.rs:37:34 --> $DIR/should_reject_intersecting.rs:37:34
@ -20,15 +20,15 @@ error[E0277]: `B` cannot be safely transmuted into `A` in the defining scope of
LL | assert::is_transmutable::<B, A>(); LL | assert::is_transmutable::<B, A>();
| ^ `B` cannot be safely transmuted into `A` in the defining scope of `assert::Context`. | ^ `B` cannot be safely transmuted into `A` in the defining scope of `assert::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<B, assert::Context, false, false, false, true>` is not implemented for `A` = help: the trait `BikeshedIntrinsicFrom<B, assert::Context, Assume { alignment: false, lifetimes: false, safety: true, validity: false }>` is not implemented for `A`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/should_reject_intersecting.rs:14:14 --> $DIR/should_reject_intersecting.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, true> LL | Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error: aborting due to 2 previous errors error: aborting due to 2 previous errors

View File

@ -7,12 +7,12 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::{Assume, BikeshedIntrinsicFrom};
pub fn is_transmutable<Src, Dst, Context>() pub fn is_transmutable<Src, Dst, Context>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, true> Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
// visibility IS assumed -------------------------------------^^^^ // safety IS assumed --------------------^^^^^^^^^^^^^^^^^^
{} {}
} }

View File

@ -7,12 +7,12 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::{Assume, BikeshedIntrinsicFrom};
pub fn is_transmutable<Src, Dst, Context>() pub fn is_transmutable<Src, Dst, Context>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, true> Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
// visibility IS assumed -------------------------------------^^^^ // safety IS assumed --------------------^^^^^^^^^^^^^^^^^^
{} {}
} }

View File

@ -13,12 +13,12 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::{Assume, BikeshedIntrinsicFrom};
pub fn is_transmutable<Src, Dst, Context>() pub fn is_transmutable<Src, Dst, Context>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, true> Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
// visibility IS assumed -------------------------------------^^^^ // safety IS assumed --------------------^^^^^^^^^^^^^^^^^^
{} {}
} }

View File

@ -8,12 +8,12 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::{Assume, BikeshedIntrinsicFrom};
pub fn is_transmutable<Src, Dst, Context>() pub fn is_transmutable<Src, Dst, Context>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, true> Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
// visibility IS assumed -------------------------------------^^^^ // safety IS assumed --------------------^^^^^^^^^^^^^^^^^^
{} {}
} }

View File

@ -8,12 +8,12 @@
#![allow(dead_code)] #![allow(dead_code)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::{Assume, BikeshedIntrinsicFrom};
pub fn is_transmutable<Src, Dst, Context>() pub fn is_transmutable<Src, Dst, Context>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, true> Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
// visibility IS assumed -------------------------------------^^^^ // safety IS assumed --------------------^^^^^^^^^^^^^^^^^^
{} {}
} }

View File

@ -11,8 +11,7 @@ mod assert {
pub fn is_transmutable<Src, Dst, Context>() pub fn is_transmutable<Src, Dst, Context>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, false> Dst: BikeshedIntrinsicFrom<Src, Context> // safety is NOT assumed
// visibility is NOT assumed ---------------------------------^^^^^
{} {}
} }

View File

@ -11,8 +11,7 @@ mod assert {
pub fn is_transmutable<Src, Dst, Context>() pub fn is_transmutable<Src, Dst, Context>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, false> Dst: BikeshedIntrinsicFrom<Src, Context> // safety is NOT assumed
// visibility is NOT assumed ---------------------------------^^^^^
{} {}
} }

View File

@ -11,8 +11,7 @@ mod assert {
pub fn is_transmutable<Src, Dst, Context>() pub fn is_transmutable<Src, Dst, Context>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, false> Dst: BikeshedIntrinsicFrom<Src, Context> // safety is NOT assumed
// visibility is NOT assumed ---------------------------------^^^^^
{} {}
} }

View File

@ -1,5 +1,5 @@
error[E0446]: private type `src::Zst` in public interface error[E0446]: private type `src::Zst` in public interface
--> $DIR/should_accept_if_src_has_unreachable_field.rs:23:9 --> $DIR/should_accept_if_src_has_unreachable_field.rs:22:9
| |
LL | #[repr(C)] pub(self) struct Zst; // <- unreachable type LL | #[repr(C)] pub(self) struct Zst; // <- unreachable type
| -------------------- `src::Zst` declared as private | -------------------- `src::Zst` declared as private

View File

@ -11,8 +11,7 @@ mod assert {
pub fn is_transmutable<Src, Dst, Context>() pub fn is_transmutable<Src, Dst, Context>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, false> Dst: BikeshedIntrinsicFrom<Src, Context> // safety is NOT assumed
// visibility is NOT assumed ---------------------------------^^^^^
{} {}
} }

View File

@ -1,11 +1,11 @@
error[E0603]: struct `Src` is private error[E0603]: struct `Src` is private
--> $DIR/should_accept_if_src_has_unreachable_ty.rs:38:36 --> $DIR/should_accept_if_src_has_unreachable_ty.rs:37:36
| |
LL | assert::is_transmutable::<src::Src, dst::Dst, Context>(); LL | assert::is_transmutable::<src::Src, dst::Dst, Context>();
| ^^^ private struct | ^^^ private struct
| |
note: the struct `Src` is defined here note: the struct `Src` is defined here
--> $DIR/should_accept_if_src_has_unreachable_ty.rs:23:16 --> $DIR/should_accept_if_src_has_unreachable_ty.rs:22:16
| |
LL | #[repr(C)] pub(self) struct Src { LL | #[repr(C)] pub(self) struct Src {
| ^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^

View File

@ -10,8 +10,7 @@ mod assert {
pub fn is_transmutable<Src, Dst, Context>() pub fn is_transmutable<Src, Dst, Context>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, false> Dst: BikeshedIntrinsicFrom<Src, Context> // safety is NOT assumed
// visibility is NOT assumed ---------------------------------^^^^^
{} {}
} }

View File

@ -1,18 +1,18 @@
error[E0277]: `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`. error[E0277]: `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`.
--> $DIR/should_reject_if_dst_has_private_field.rs:36:41 --> $DIR/should_reject_if_dst_has_private_field.rs:35:41
| |
LL | assert::is_transmutable::<src::Src, dst::Dst, Context>(); LL | assert::is_transmutable::<src::Src, dst::Dst, Context>();
| ^^^^^^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`. | ^^^^^^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<Src, test::Context, false, false, false, false>` is not implemented for `Dst` = help: the trait `BikeshedIntrinsicFrom<Src, test::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `Dst`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/should_reject_if_dst_has_private_field.rs:13:14 --> $DIR/should_reject_if_dst_has_private_field.rs:13:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, false> LL | Dst: BikeshedIntrinsicFrom<Src, Context> // safety is NOT assumed
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error: aborting due to previous error error: aborting due to previous error

View File

@ -10,8 +10,7 @@ mod assert {
pub fn is_transmutable<Src, Dst, Context>() pub fn is_transmutable<Src, Dst, Context>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, false> Dst: BikeshedIntrinsicFrom<Src, Context> // safety is NOT assumed
// visibility is NOT assumed ---------------------------------^^^^^
{} {}
} }

View File

@ -1,18 +1,18 @@
error[E0277]: `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`. error[E0277]: `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`.
--> $DIR/should_reject_if_dst_has_private_variant.rs:37:41 --> $DIR/should_reject_if_dst_has_private_variant.rs:36:41
| |
LL | assert::is_transmutable::<src::Src, dst::Dst, Context>(); LL | assert::is_transmutable::<src::Src, dst::Dst, Context>();
| ^^^^^^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`. | ^^^^^^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<Src, test::Context, false, false, false, false>` is not implemented for `Dst` = help: the trait `BikeshedIntrinsicFrom<Src, test::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `Dst`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/should_reject_if_dst_has_private_variant.rs:13:14 --> $DIR/should_reject_if_dst_has_private_variant.rs:13:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, false> LL | Dst: BikeshedIntrinsicFrom<Src, Context> // safety is NOT assumed
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error: aborting due to previous error error: aborting due to previous error

View File

@ -23,8 +23,7 @@ mod assert {
pub fn is_transmutable<Src, Dst, Context>() pub fn is_transmutable<Src, Dst, Context>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, false> Dst: BikeshedIntrinsicFrom<Src, Context> // safety is NOT assumed
// visibility is NOT assumed ---------------------------------^^^^^
{} {}
} }

View File

@ -12,8 +12,7 @@ mod assert {
pub fn is_transmutable<Src, Dst, Context>() pub fn is_transmutable<Src, Dst, Context>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, false> Dst: BikeshedIntrinsicFrom<Src, Context> // safety is NOT assumed
// visibility is NOT assumed ---------------------------------^^^^^
{} {}
} }

View File

@ -1,18 +1,18 @@
error[E0277]: `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`. error[E0277]: `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`.
--> $DIR/should_reject_if_dst_has_unreachable_field.rs:38:41 --> $DIR/should_reject_if_dst_has_unreachable_field.rs:37:41
| |
LL | assert::is_transmutable::<src::Src, dst::Dst, Context>(); LL | assert::is_transmutable::<src::Src, dst::Dst, Context>();
| ^^^^^^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`. | ^^^^^^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<Src, test::Context, false, false, false, false>` is not implemented for `Dst` = help: the trait `BikeshedIntrinsicFrom<Src, test::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `Dst`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/should_reject_if_dst_has_unreachable_field.rs:15:14 --> $DIR/should_reject_if_dst_has_unreachable_field.rs:15:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, false> LL | Dst: BikeshedIntrinsicFrom<Src, Context> // safety is NOT assumed
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error: aborting due to previous error error: aborting due to previous error

View File

@ -12,8 +12,7 @@ mod assert {
pub fn is_transmutable<Src, Dst, Context>() pub fn is_transmutable<Src, Dst, Context>()
where where
Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, false> Dst: BikeshedIntrinsicFrom<Src, Context> // safety is NOT assumed
// visibility is NOT assumed ---------------------------------^^^^^
{} {}
} }

View File

@ -1,30 +1,30 @@
error[E0603]: struct `Dst` is private error[E0603]: struct `Dst` is private
--> $DIR/should_reject_if_dst_has_unreachable_ty.rs:39:46 --> $DIR/should_reject_if_dst_has_unreachable_ty.rs:38:46
| |
LL | assert::is_transmutable::<src::Src, dst::Dst, Context>(); LL | assert::is_transmutable::<src::Src, dst::Dst, Context>();
| ^^^ private struct | ^^^ private struct
| |
note: the struct `Dst` is defined here note: the struct `Dst` is defined here
--> $DIR/should_reject_if_dst_has_unreachable_ty.rs:32:16 --> $DIR/should_reject_if_dst_has_unreachable_ty.rs:31:16
| |
LL | #[repr(C)] pub(self) struct Dst { LL | #[repr(C)] pub(self) struct Dst {
| ^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^
error[E0277]: `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`. error[E0277]: `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`.
--> $DIR/should_reject_if_dst_has_unreachable_ty.rs:39:41 --> $DIR/should_reject_if_dst_has_unreachable_ty.rs:38:41
| |
LL | assert::is_transmutable::<src::Src, dst::Dst, Context>(); LL | assert::is_transmutable::<src::Src, dst::Dst, Context>();
| ^^^^^^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`. | ^^^^^^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`.
| |
= help: the trait `BikeshedIntrinsicFrom<Src, test::Context, false, false, false, false>` is not implemented for `Dst` = help: the trait `BikeshedIntrinsicFrom<Src, test::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `Dst`
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/should_reject_if_dst_has_unreachable_ty.rs:15:14 --> $DIR/should_reject_if_dst_has_unreachable_ty.rs:15:14
| |
LL | pub fn is_transmutable<Src, Dst, Context>() LL | pub fn is_transmutable<Src, Dst, Context>()
| --------------- required by a bound in this | --------------- required by a bound in this
LL | where LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, false, false, false, false> LL | Dst: BikeshedIntrinsicFrom<Src, Context> // safety is NOT assumed
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error: aborting due to 2 previous errors error: aborting due to 2 previous errors