diff --git a/compiler/rustc_hir_typeck/src/generator_interior/mod.rs b/compiler/rustc_hir_typeck/src/generator_interior/mod.rs
index 5faa6ab13dd7d..f397108044333 100644
--- a/compiler/rustc_hir_typeck/src/generator_interior/mod.rs
+++ b/compiler/rustc_hir_typeck/src/generator_interior/mod.rs
@@ -239,8 +239,7 @@ pub fn resolve_interior<'a, 'tcx>(
// typeck had previously found constraints that would cause them to be related.
let mut counter = 0;
- let mut mk_bound_region = |span| {
- let kind = ty::BrAnon(span);
+ let mut mk_bound_region = |kind| {
let var = ty::BoundVar::from_u32(counter);
counter += 1;
ty::BoundRegion { var, kind }
@@ -252,24 +251,23 @@ pub fn resolve_interior<'a, 'tcx>(
let origin = fcx.region_var_origin(vid);
match origin {
RegionVariableOrigin::EarlyBoundRegion(span, _) => {
- mk_bound_region(Some(span))
+ mk_bound_region(ty::BrAnon(Some(span)))
}
- _ => mk_bound_region(None),
+ _ => mk_bound_region(ty::BrAnon(None)),
}
}
- // FIXME: these should use `BrNamed`
ty::ReEarlyBound(region) => {
- mk_bound_region(Some(fcx.tcx.def_span(region.def_id)))
+ mk_bound_region(ty::BrNamed(region.def_id, region.name))
}
ty::ReLateBound(_, ty::BoundRegion { kind, .. })
| ty::ReFree(ty::FreeRegion { bound_region: kind, .. }) => match kind {
- ty::BoundRegionKind::BrAnon(span) => mk_bound_region(span),
- ty::BoundRegionKind::BrNamed(def_id, _) => {
- mk_bound_region(Some(fcx.tcx.def_span(def_id)))
+ ty::BoundRegionKind::BrAnon(span) => mk_bound_region(ty::BrAnon(span)),
+ ty::BoundRegionKind::BrNamed(def_id, sym) => {
+ mk_bound_region(ty::BrNamed(def_id, sym))
}
- ty::BoundRegionKind::BrEnv => mk_bound_region(None),
+ ty::BoundRegionKind::BrEnv => mk_bound_region(ty::BrAnon(None)),
},
- _ => mk_bound_region(None),
+ _ => mk_bound_region(ty::BrAnon(None)),
};
let r = fcx.tcx.mk_re_late_bound(current_depth, br);
r
@@ -293,10 +291,7 @@ pub fn resolve_interior<'a, 'tcx>(
type_causes,
FnMutDelegate {
regions: &mut |br| {
- let kind = match br.kind {
- ty::BrAnon(span) => ty::BrAnon(span),
- _ => br.kind,
- };
+ let kind = br.kind;
let var = ty::BoundVar::from_usize(bound_vars.len());
bound_vars.push(ty::BoundVariableKind::Region(kind));
counter += 1;
diff --git a/compiler/rustc_middle/src/hir/mod.rs b/compiler/rustc_middle/src/hir/mod.rs
index 0d8a8c9cdfd43..7770a5e476418 100644
--- a/compiler/rustc_middle/src/hir/mod.rs
+++ b/compiler/rustc_middle/src/hir/mod.rs
@@ -7,7 +7,7 @@ pub mod nested_filter;
pub mod place;
use crate::ty::query::Providers;
-use crate::ty::{ImplSubject, TyCtxt};
+use crate::ty::{EarlyBinder, ImplSubject, TyCtxt};
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_data_structures::sync::{par_for_each_in, Send, Sync};
use rustc_hir::def_id::{DefId, LocalDefId};
@@ -104,11 +104,11 @@ impl<'tcx> TyCtxt<'tcx> {
self.parent_module_from_def_id(id.owner.def_id)
}
- pub fn impl_subject(self, def_id: DefId) -> ImplSubject<'tcx> {
- self.impl_trait_ref(def_id)
- .map(|t| t.subst_identity())
- .map(ImplSubject::Trait)
- .unwrap_or_else(|| ImplSubject::Inherent(self.type_of(def_id).subst_identity()))
+ pub fn impl_subject(self, def_id: DefId) -> EarlyBinder<ImplSubject<'tcx>> {
+ match self.impl_trait_ref(def_id) {
+ Some(t) => t.map_bound(ImplSubject::Trait),
+ None => self.type_of(def_id).map_bound(ImplSubject::Inherent),
+ }
}
}
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index 4411bcd927d71..c8a78ec03d947 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -708,10 +708,6 @@ impl<'tcx> TyCtxt<'tcx> {
ty::EarlyBinder(self.explicit_item_bounds(def_id))
}
- pub fn bound_impl_subject(self, def_id: DefId) -> ty::EarlyBinder<ty::ImplSubject<'tcx>> {
- ty::EarlyBinder(self.impl_subject(def_id))
- }
-
/// Returns names of captured upvars for closures and generators.
///
/// Here are some examples:
diff --git a/compiler/rustc_trait_selection/src/solve/assembly/mod.rs b/compiler/rustc_trait_selection/src/solve/assembly/mod.rs
index 7f0ceb6646ceb..10d817f75ac77 100644
--- a/compiler/rustc_trait_selection/src/solve/assembly/mod.rs
+++ b/compiler/rustc_trait_selection/src/solve/assembly/mod.rs
@@ -348,6 +348,14 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
) {
let lang_items = self.tcx().lang_items();
let trait_def_id = goal.predicate.trait_def_id(self.tcx());
+
+ // N.B. When assembling built-in candidates for lang items that are also
+ // `auto` traits, then the auto trait candidate that is assembled in
+ // `consider_auto_trait_candidate` MUST be disqualified to remain sound.
+ //
+ // Instead of adding the logic here, it's a better idea to add it in
+ // `EvalCtxt::disqualify_auto_trait_candidate_due_to_possible_impl` in
+ // `solve::trait_goals` instead.
let result = if self.tcx().trait_is_auto(trait_def_id) {
G::consider_auto_trait_candidate(self, goal)
} else if self.tcx().trait_is_alias(trait_def_id) {
diff --git a/compiler/rustc_trait_selection/src/solve/canonicalize.rs b/compiler/rustc_trait_selection/src/solve/canonicalize.rs
index 25e7439ece791..976849696e33a 100644
--- a/compiler/rustc_trait_selection/src/solve/canonicalize.rs
+++ b/compiler/rustc_trait_selection/src/solve/canonicalize.rs
@@ -125,8 +125,9 @@ impl<'a, 'tcx> Canonicalizer<'a, 'tcx> {
// - var_infos: [E0, U1, E1, U1, E1, E6, U6], curr_compressed_uv: 1, next_orig_uv: 6
// - var_infos: [E0, U1, E1, U1, E1, E2, U2], curr_compressed_uv: 2, next_orig_uv: -
//
- // This algorithm runs in `O(n²)` where `n` is the number of different universe
- // indices in the input. This should be fine as `n` is expected to be small.
+ // This algorithm runs in `O(nm)` where `n` is the number of different universe
+ // indices in the input and `m` is the number of canonical variables.
+ // This should be fine as both `n` and `m` are expected to be small.
let mut curr_compressed_uv = ty::UniverseIndex::ROOT;
let mut existential_in_new_uv = false;
let mut next_orig_uv = Some(ty::UniverseIndex::ROOT);
@@ -245,18 +246,14 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'_, 'tcx> {
ty::ReError(_) => return r,
};
- let existing_bound_var = match self.canonicalize_mode {
- CanonicalizeMode::Input => None,
- CanonicalizeMode::Response { .. } => {
- self.variables.iter().position(|&v| v == r.into()).map(ty::BoundVar::from)
- }
- };
- let var = existing_bound_var.unwrap_or_else(|| {
- let var = ty::BoundVar::from(self.variables.len());
- self.variables.push(r.into());
- self.primitive_var_infos.push(CanonicalVarInfo { kind });
- var
- });
+ let var = ty::BoundVar::from(
+ self.variables.iter().position(|&v| v == r.into()).unwrap_or_else(|| {
+ let var = self.variables.len();
+ self.variables.push(r.into());
+ self.primitive_var_infos.push(CanonicalVarInfo { kind });
+ var
+ }),
+ );
let br = ty::BoundRegion { var, kind: BrAnon(None) };
self.interner().mk_re_late_bound(self.binder_index, br)
}
diff --git a/compiler/rustc_trait_selection/src/solve/trait_goals.rs b/compiler/rustc_trait_selection/src/solve/trait_goals.rs
index 716d5acb324a2..abd11a15ac23a 100644
--- a/compiler/rustc_trait_selection/src/solve/trait_goals.rs
+++ b/compiler/rustc_trait_selection/src/solve/trait_goals.rs
@@ -3,7 +3,7 @@
use super::assembly::{self, structural_traits};
use super::{EvalCtxt, SolverMode};
use rustc_hir::def_id::DefId;
-use rustc_hir::LangItem;
+use rustc_hir::{LangItem, Movability};
use rustc_infer::traits::query::NoSolution;
use rustc_infer::traits::util::supertraits;
use rustc_middle::traits::solve::{CanonicalResponse, Certainty, Goal, QueryResult};
@@ -147,66 +147,8 @@ impl<'tcx> assembly::GoalKind<'tcx> for TraitPredicate<'tcx> {
ecx: &mut EvalCtxt<'_, 'tcx>,
goal: Goal<'tcx, Self>,
) -> QueryResult<'tcx> {
- let self_ty = goal.predicate.self_ty();
- match *self_ty.kind() {
- // Stall int and float vars until they are resolved to a concrete
- // numerical type. That's because the check for impls below treats
- // int vars as matching any impl. Even if we filtered such impls,
- // we probably don't want to treat an `impl !AutoTrait for i32` as
- // disqualifying the built-in auto impl for `i64: AutoTrait` either.
- ty::Infer(ty::IntVar(_) | ty::FloatVar(_)) => {
- return ecx.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS);
- }
-
- // These types cannot be structurally decomposed into constitutent
- // types, and therefore have no builtin impl.
- ty::Dynamic(..)
- | ty::Param(..)
- | ty::Foreign(..)
- | ty::Alias(ty::Projection, ..)
- | ty::Placeholder(..) => return Err(NoSolution),
-
- ty::Infer(_) | ty::Bound(_, _) => bug!("unexpected type `{self_ty}`"),
-
- // For rigid types, we only register a builtin auto implementation
- // if there is no implementation that could ever apply to the self
- // type.
- //
- // This differs from the current stable behavior and fixes #84857.
- // Due to breakage found via crater, we currently instead lint
- // patterns which can be used to exploit this unsoundness on stable,
- // see #93367 for more details.
- ty::Bool
- | ty::Char
- | ty::Int(_)
- | ty::Uint(_)
- | ty::Float(_)
- | ty::Str
- | ty::Array(_, _)
- | ty::Slice(_)
- | ty::RawPtr(_)
- | ty::Ref(_, _, _)
- | ty::FnDef(_, _)
- | ty::FnPtr(_)
- | ty::Closure(_, _)
- | ty::Generator(_, _, _)
- | ty::GeneratorWitness(_)
- | ty::GeneratorWitnessMIR(_, _)
- | ty::Never
- | ty::Tuple(_)
- | ty::Error(_)
- | ty::Adt(_, _)
- | ty::Alias(ty::Opaque, _) => {
- if let Some(def_id) = ecx.tcx().find_map_relevant_impl(
- goal.predicate.def_id(),
- goal.predicate.self_ty(),
- TreatProjections::NextSolverLookup,
- Some,
- ) {
- debug!(?def_id, ?goal, "disqualified auto-trait implementation");
- return Err(NoSolution);
- }
- }
+ if let Some(result) = ecx.disqualify_auto_trait_candidate_due_to_possible_impl(goal) {
+ return result;
}
ecx.probe_and_evaluate_goal_for_constituent_tys(
@@ -630,6 +572,97 @@ impl<'tcx> assembly::GoalKind<'tcx> for TraitPredicate<'tcx> {
}
impl<'tcx> EvalCtxt<'_, 'tcx> {
+ // Return `Some` if there is an impl (built-in or user provided) that may
+ // hold for the self type of the goal, which for coherence and soundness
+ // purposes must disqualify the built-in auto impl assembled by considering
+ // the type's constituent types.
+ fn disqualify_auto_trait_candidate_due_to_possible_impl(
+ &mut self,
+ goal: Goal<'tcx, TraitPredicate<'tcx>>,
+ ) -> Option<QueryResult<'tcx>> {
+ let self_ty = goal.predicate.self_ty();
+ match *self_ty.kind() {
+ // Stall int and float vars until they are resolved to a concrete
+ // numerical type. That's because the check for impls below treats
+ // int vars as matching any impl. Even if we filtered such impls,
+ // we probably don't want to treat an `impl !AutoTrait for i32` as
+ // disqualifying the built-in auto impl for `i64: AutoTrait` either.
+ ty::Infer(ty::IntVar(_) | ty::FloatVar(_)) => {
+ Some(self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS))
+ }
+
+ // These types cannot be structurally decomposed into constitutent
+ // types, and therefore have no built-in auto impl.
+ ty::Dynamic(..)
+ | ty::Param(..)
+ | ty::Foreign(..)
+ | ty::Alias(ty::Projection, ..)
+ | ty::Placeholder(..) => Some(Err(NoSolution)),
+
+ ty::Infer(_) | ty::Bound(_, _) => bug!("unexpected type `{self_ty}`"),
+
+ // Generators have one special built-in candidate, `Unpin`, which
+ // takes precedence over the structural auto trait candidate being
+ // assembled.
+ ty::Generator(_, _, movability)
+ if Some(goal.predicate.def_id()) == self.tcx().lang_items().unpin_trait() =>
+ {
+ match movability {
+ Movability::Static => Some(Err(NoSolution)),
+ Movability::Movable => {
+ Some(self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes))
+ }
+ }
+ }
+
+ // For rigid types, any possible implementation that could apply to
+ // the type (even if after unification and processing nested goals
+ // it does not hold) will disqualify the built-in auto impl.
+ //
+ // This differs from the current stable behavior and fixes #84857.
+ // Due to breakage found via crater, we currently instead lint
+ // patterns which can be used to exploit this unsoundness on stable,
+ // see #93367 for more details.
+ ty::Bool
+ | ty::Char
+ | ty::Int(_)
+ | ty::Uint(_)
+ | ty::Float(_)
+ | ty::Str
+ | ty::Array(_, _)
+ | ty::Slice(_)
+ | ty::RawPtr(_)
+ | ty::Ref(_, _, _)
+ | ty::FnDef(_, _)
+ | ty::FnPtr(_)
+ | ty::Closure(_, _)
+ | ty::Generator(_, _, _)
+ | ty::GeneratorWitness(_)
+ | ty::GeneratorWitnessMIR(_, _)
+ | ty::Never
+ | ty::Tuple(_)
+ | ty::Adt(_, _)
+ // FIXME: Handling opaques here is kinda sus. Especially because we
+ // simplify them to PlaceholderSimplifiedType.
+ | ty::Alias(ty::Opaque, _) => {
+ if let Some(def_id) = self.tcx().find_map_relevant_impl(
+ goal.predicate.def_id(),
+ goal.predicate.self_ty(),
+ TreatProjections::NextSolverLookup,
+ Some,
+ ) {
+ debug!(?def_id, ?goal, "disqualified auto-trait implementation");
+ // No need to actually consider the candidate here,
+ // since we do that in `consider_impl_candidate`.
+ return Some(Err(NoSolution));
+ } else {
+ None
+ }
+ }
+ ty::Error(_) => None,
+ }
+ }
+
/// Convenience function for traits that are structural, i.e. that only
/// have nested subgoals that only change the self type. Unlike other
/// evaluate-like helpers, this does a probe, so it doesn't need to be
diff --git a/compiler/rustc_trait_selection/src/traits/coherence.rs b/compiler/rustc_trait_selection/src/traits/coherence.rs
index 3c918b6028d47..20c2605f219a7 100644
--- a/compiler/rustc_trait_selection/src/traits/coherence.rs
+++ b/compiler/rustc_trait_selection/src/traits/coherence.rs
@@ -306,7 +306,7 @@ fn negative_impl(tcx: TyCtxt<'_>, impl1_def_id: DefId, impl2_def_id: DefId) -> b
&infcx,
ObligationCause::dummy(),
impl_env,
- tcx.impl_subject(impl1_def_id),
+ tcx.impl_subject(impl1_def_id).subst_identity(),
) {
Ok(s) => s,
Err(err) => {
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
index 0ef6579664a61..1b741b7302b67 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
@@ -673,6 +673,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
return;
}
let trait_ref = trait_predicate.to_poly_trait_ref();
+
let (post_message, pre_message, type_def) = self
.get_parent_trait_ref(obligation.cause.code())
.map(|(t, s)| {
@@ -712,33 +713,45 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
(message, note, append_const_msg)
};
- let mut err = struct_span_err!(
- self.tcx.sess,
- span,
- E0277,
- "{}",
- message
- .and_then(|cannot_do_this| {
- match (predicate_is_const, append_const_msg) {
- // do nothing if predicate is not const
- (false, _) => Some(cannot_do_this),
- // suggested using default post message
- (true, Some(None)) => {
- Some(format!("{cannot_do_this} in const contexts"))
- }
- // overridden post message
- (true, Some(Some(post_message))) => {
- Some(format!("{cannot_do_this}{post_message}"))
- }
- // fallback to generic message
- (true, None) => None,
+ let err_msg = message
+ .and_then(|cannot_do_this| {
+ match (predicate_is_const, append_const_msg) {
+ // do nothing if predicate is not const
+ (false, _) => Some(cannot_do_this),
+ // suggested using default post message
+ (true, Some(None)) => {
+ Some(format!("{cannot_do_this} in const contexts"))
+ }
+ // overridden post message
+ (true, Some(Some(post_message))) => {
+ Some(format!("{cannot_do_this}{post_message}"))
}
- })
- .unwrap_or_else(|| format!(
+ // fallback to generic message
+ (true, None) => None,
+ }
+ })
+ .unwrap_or_else(|| {
+ format!(
"the trait bound `{}` is not satisfied{}",
trait_predicate, post_message,
- ))
- );
+ )
+ });
+
+ let (err_msg, safe_transmute_explanation) = if Some(trait_ref.def_id())
+ == self.tcx.lang_items().transmute_trait()
+ {
+ // Recompute the safe transmute reason and use that for the error reporting
+ self.get_safe_transmute_error_and_reason(
+ trait_predicate,
+ obligation.clone(),
+ trait_ref,
+ span,
+ )
+ } else {
+ (err_msg, None)
+ };
+
+ let mut err = struct_span_err!(self.tcx.sess, span, E0277, "{}", err_msg);
if is_try_conversion && let Some(ret_span) = self.return_type_span(&obligation) {
err.span_label(
@@ -828,6 +841,8 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
// at the type param with a label to suggest constraining it.
err.help(&explanation);
}
+ } else if let Some(custom_explanation) = safe_transmute_explanation {
+ err.span_label(span, custom_explanation);
} else {
err.span_label(span, explanation);
}
@@ -1611,6 +1626,14 @@ trait InferCtxtPrivExt<'tcx> {
obligated_types: &mut Vec<Ty<'tcx>>,
cause_code: &ObligationCauseCode<'tcx>,
) -> bool;
+
+ fn get_safe_transmute_error_and_reason(
+ &self,
+ trait_predicate: ty::Binder<'tcx, ty::TraitPredicate<'tcx>>,
+ obligation: Obligation<'tcx, ty::Predicate<'tcx>>,
+ trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+ span: Span,
+ ) -> (String, Option<String>);
}
impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
@@ -2895,6 +2918,63 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
}
false
}
+
+ fn get_safe_transmute_error_and_reason(
+ &self,
+ trait_predicate: ty::Binder<'tcx, ty::TraitPredicate<'tcx>>,
+ obligation: Obligation<'tcx, ty::Predicate<'tcx>>,
+ trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+ span: Span,
+ ) -> (String, Option<String>) {
+ let src_and_dst = trait_predicate.map_bound(|p| rustc_transmute::Types {
+ dst: p.trait_ref.substs.type_at(0),
+ src: p.trait_ref.substs.type_at(1),
+ });
+ let scope = trait_ref.skip_binder().substs.type_at(2);
+ let Some(assume) =
+ rustc_transmute::Assume::from_const(self.infcx.tcx, obligation.param_env, trait_ref.skip_binder().substs.const_at(3)) else {
+ span_bug!(span, "Unable to construct rustc_transmute::Assume where it was previously possible");
+ };
+ match rustc_transmute::TransmuteTypeEnv::new(self.infcx).is_transmutable(
+ obligation.cause,
+ src_and_dst,
+ scope,
+ assume,
+ ) {
+ rustc_transmute::Answer::No(reason) => {
+ let dst = trait_ref.skip_binder().substs.type_at(0);
+ let src = trait_ref.skip_binder().substs.type_at(1);
+ let custom_err_msg = format!("`{src}` cannot be safely transmuted into `{dst}` in the defining scope of `{scope}`").to_string();
+ let reason_msg = match reason {
+ rustc_transmute::Reason::SrcIsUnspecified => {
+ format!("`{src}` does not have a well-specified layout").to_string()
+ }
+ rustc_transmute::Reason::DstIsUnspecified => {
+ format!("`{dst}` does not have a well-specified layout").to_string()
+ }
+ rustc_transmute::Reason::DstIsBitIncompatible => {
+ format!("At least one value of `{src}` isn't a bit-valid value of `{dst}`")
+ .to_string()
+ }
+ rustc_transmute::Reason::DstIsPrivate => format!(
+ "`{dst}` is or contains a type or field that is not visible in that scope"
+ )
+ .to_string(),
+ // FIXME(bryangarza): Include the number of bytes of src and dst
+ rustc_transmute::Reason::DstIsTooBig => {
+ format!("The size of `{src}` is smaller than the size of `{dst}`")
+ }
+ };
+ (custom_err_msg, Some(reason_msg))
+ }
+ // Should never get a Yes at this point! We already ran it before, and did not get a Yes.
+ rustc_transmute::Answer::Yes => span_bug!(
+ span,
+ "Inconsistent rustc_transmute::is_transmutable(...) result, got Yes",
+ ),
+ _ => span_bug!(span, "Unsupported rustc_transmute::Reason variant"),
+ }
+ }
}
/// Crude way of getting back an `Expr` from a `Span`.
diff --git a/compiler/rustc_trait_selection/src/traits/util.rs b/compiler/rustc_trait_selection/src/traits/util.rs
index 60630979b34e4..20357d4d2501a 100644
--- a/compiler/rustc_trait_selection/src/traits/util.rs
+++ b/compiler/rustc_trait_selection/src/traits/util.rs
@@ -198,7 +198,7 @@ pub fn impl_subject_and_oblig<'a, 'tcx>(
impl_def_id: DefId,
impl_substs: SubstsRef<'tcx>,
) -> (ImplSubject<'tcx>, impl Iterator<Item = PredicateObligation<'tcx>>) {
- let subject = selcx.tcx().bound_impl_subject(impl_def_id);
+ let subject = selcx.tcx().impl_subject(impl_def_id);
let subject = subject.subst(selcx.tcx(), impl_substs);
let InferOk { value: subject, obligations: normalization_obligations1 } =
diff --git a/compiler/rustc_transmute/src/layout/tree.rs b/compiler/rustc_transmute/src/layout/tree.rs
index 295b65c2cc925..2a89494c80b04 100644
--- a/compiler/rustc_transmute/src/layout/tree.rs
+++ b/compiler/rustc_transmute/src/layout/tree.rs
@@ -167,31 +167,31 @@ where
}
}
-#[derive(Debug, Copy, Clone)]
-pub(crate) enum Err {
- /// The layout of the type is unspecified.
- Unspecified,
- /// This error will be surfaced elsewhere by rustc, so don't surface it.
- Unknown,
-}
-
#[cfg(feature = "rustc")]
pub(crate) mod rustc {
- use super::{Err, Tree};
+ use super::Tree;
use crate::layout::rustc::{Def, Ref};
- use rustc_middle::ty;
use rustc_middle::ty::layout::LayoutError;
use rustc_middle::ty::util::Discr;
use rustc_middle::ty::AdtDef;
use rustc_middle::ty::ParamEnv;
use rustc_middle::ty::SubstsRef;
- use rustc_middle::ty::Ty;
- use rustc_middle::ty::TyCtxt;
use rustc_middle::ty::VariantDef;
+ use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt};
+ use rustc_span::ErrorGuaranteed;
use rustc_target::abi::Align;
use std::alloc;
+ #[derive(Debug, Copy, Clone)]
+ pub(crate) enum Err {
+ /// The layout of the type is unspecified.
+ Unspecified,
+ /// This error will be surfaced elsewhere by rustc, so don't surface it.
+ Unknown,
+ TypeError(ErrorGuaranteed),
+ }
+
impl<'tcx> From<LayoutError<'tcx>> for Err {
fn from(err: LayoutError<'tcx>) -> Self {
match err {
@@ -261,6 +261,10 @@ pub(crate) mod rustc {
use rustc_middle::ty::UintTy::*;
use rustc_target::abi::HasDataLayout;
+ if let Err(e) = ty.error_reported() {
+ return Err(Err::TypeError(e));
+ }
+
let target = tcx.data_layout();
match ty.kind() {
diff --git a/compiler/rustc_transmute/src/maybe_transmutable/mod.rs b/compiler/rustc_transmute/src/maybe_transmutable/mod.rs
index 1186eac37abd9..2e2fb90e71c1a 100644
--- a/compiler/rustc_transmute/src/maybe_transmutable/mod.rs
+++ b/compiler/rustc_transmute/src/maybe_transmutable/mod.rs
@@ -56,7 +56,7 @@ where
#[cfg(feature = "rustc")]
mod rustc {
use super::*;
- use crate::layout::tree::Err;
+ use crate::layout::tree::rustc::Err;
use rustc_middle::ty::Ty;
use rustc_middle::ty::TyCtxt;
@@ -71,19 +71,20 @@ mod rustc {
// representations. If these conversions fail, conclude that the transmutation is
// unacceptable; the layouts of both the source and destination types must be
// well-defined.
- let src = Tree::from_ty(src, context).map_err(|err| match err {
- // Answer `Yes` here, because "Unknown Type" will already be reported by
- // rustc. No need to spam the user with more errors.
- Err::Unknown => Answer::Yes,
- Err::Unspecified => Answer::No(Reason::SrcIsUnspecified),
- })?;
+ let src = Tree::from_ty(src, context);
+ let dst = Tree::from_ty(dst, context);
- let dst = Tree::from_ty(dst, context).map_err(|err| match err {
- Err::Unknown => Answer::Yes,
- Err::Unspecified => Answer::No(Reason::DstIsUnspecified),
- })?;
-
- Ok((src, dst))
+ match (src, dst) {
+ // Answer `Yes` here, because 'unknown layout' and type errors will already
+ // be reported by rustc. No need to spam the user with more errors.
+ (Err(Err::TypeError(_)), _) => Err(Answer::Yes),
+ (_, Err(Err::TypeError(_))) => Err(Answer::Yes),
+ (Err(Err::Unknown), _) => Err(Answer::Yes),
+ (_, Err(Err::Unknown)) => Err(Answer::Yes),
+ (Err(Err::Unspecified), _) => Err(Answer::No(Reason::SrcIsUnspecified)),
+ (_, Err(Err::Unspecified)) => Err(Answer::No(Reason::DstIsUnspecified)),
+ (Ok(src), Ok(dst)) => Ok((src, dst)),
+ }
});
match query_or_answer {
diff --git a/compiler/rustc_transmute/src/maybe_transmutable/tests.rs b/compiler/rustc_transmute/src/maybe_transmutable/tests.rs
index 4d5772a4f2ea5..a8675f4ae37d8 100644
--- a/compiler/rustc_transmute/src/maybe_transmutable/tests.rs
+++ b/compiler/rustc_transmute/src/maybe_transmutable/tests.rs
@@ -1,6 +1,6 @@
use super::query_context::test::{Def, UltraMinimal};
use crate::maybe_transmutable::MaybeTransmutableQuery;
-use crate::{layout, Answer, Reason, Set};
+use crate::{layout, Answer, Reason};
use itertools::Itertools;
mod bool {
@@ -48,9 +48,9 @@ mod bool {
let into_set = |alts: Vec<_>| {
#[cfg(feature = "rustc")]
- let mut set = Set::default();
+ let mut set = crate::Set::default();
#[cfg(not(feature = "rustc"))]
- let mut set = Set::new();
+ let mut set = std::collections::HashSet::new();
set.extend(alts);
set
};
diff --git a/library/core/src/mem/transmutability.rs b/library/core/src/mem/transmutability.rs
index 3b98efff2938a..b53a330fa560b 100644
--- a/library/core/src/mem/transmutability.rs
+++ b/library/core/src/mem/transmutability.rs
@@ -5,10 +5,6 @@
/// notwithstanding whatever safety checks you have asked the compiler to [`Assume`] are satisfied.
#[unstable(feature = "transmutability", issue = "99571")]
#[lang = "transmute_trait"]
-#[rustc_on_unimplemented(
- 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}`."
-)]
pub unsafe trait BikeshedIntrinsicFrom<Src, Context, const ASSUME: Assume = { Assume::NOTHING }>
where
Src: ?Sized,
diff --git a/library/core/tests/num/dec2flt/mod.rs b/library/core/tests/num/dec2flt/mod.rs
index a2b9bb551e677..874e0ec7093c7 100644
--- a/library/core/tests/num/dec2flt/mod.rs
+++ b/library/core/tests/num/dec2flt/mod.rs
@@ -127,14 +127,3 @@ fn massive_exponent() {
assert_eq!(format!("1e-{max}000").parse(), Ok(0.0));
assert_eq!(format!("1e{max}000").parse(), Ok(f64::INFINITY));
}
-
-#[test]
-fn borderline_overflow() {
- let mut s = "0.".to_string();
- for _ in 0..375 {
- s.push('3');
- }
- // At the time of this writing, this returns Err(..), but this is a bug that should be fixed.
- // It makes no sense to enshrine that in a test, the important part is that it doesn't panic.
- let _ = s.parse::<f64>();
-}
diff --git a/library/std/src/f32.rs b/library/std/src/f32.rs
index c7c33678fd34c..408244b2ce9eb 100644
--- a/library/std/src/f32.rs
+++ b/library/std/src/f32.rs
@@ -581,8 +581,10 @@ impl f32 {
unsafe { cmath::cbrtf(self) }
}
- /// Calculates the length of the hypotenuse of a right-angle triangle given
- /// legs of length `x` and `y`.
+ /// Compute the distance between the origin and a point (`x`, `y`) on the
+ /// Euclidean plane. Equivalently, compute the length of the hypotenuse of a
+ /// right-angle triangle with other sides having length `x.abs()` and
+ /// `y.abs()`.
///
/// # Examples
///
diff --git a/library/std/src/f64.rs b/library/std/src/f64.rs
index b1faa670307d6..6782b861f110b 100644
--- a/library/std/src/f64.rs
+++ b/library/std/src/f64.rs
@@ -583,8 +583,10 @@ impl f64 {
unsafe { cmath::cbrt(self) }
}
- /// Calculates the length of the hypotenuse of a right-angle triangle given
- /// legs of length `x` and `y`.
+ /// Compute the distance between the origin and a point (`x`, `y`) on the
+ /// Euclidean plane. Equivalently, compute the length of the hypotenuse of a
+ /// right-angle triangle with other sides having length `x.abs()` and
+ /// `y.abs()`.
///
/// # Examples
///
diff --git a/library/std/src/thread/mod.rs b/library/std/src/thread/mod.rs
index b9aaf5f6e15db..13b845b25c92d 100644
--- a/library/std/src/thread/mod.rs
+++ b/library/std/src/thread/mod.rs
@@ -131,7 +131,8 @@
//!
//! * Build the thread with [`Builder`] and pass the desired stack size to [`Builder::stack_size`].
//! * Set the `RUST_MIN_STACK` environment variable to an integer representing the desired stack
-//! size (in bytes). Note that setting [`Builder::stack_size`] will override this.
+//! size (in bytes). Note that setting [`Builder::stack_size`] will override this. Be aware that
+//! changes to `RUST_MIN_STACK` may be ignored after program start.
//!
//! Note that the stack size of the main thread is *not* determined by Rust.
//!
diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
index e4b29fa91c863..cc5d13808b2f5 100644
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@@ -111,7 +111,7 @@ pub(crate) fn try_inline(
clean::ConstantItem(build_const(cx, did))
}
Res::Def(DefKind::Macro(kind), did) => {
- let mac = build_macro(cx, did, name, import_def_id);
+ let mac = build_macro(cx, did, name, import_def_id, kind);
let type_kind = match kind {
MacroKind::Bang => ItemType::Macro,
@@ -651,18 +651,24 @@ fn build_macro(
def_id: DefId,
name: Symbol,
import_def_id: Option<DefId>,
+ macro_kind: MacroKind,
) -> clean::ItemKind {
match CStore::from_tcx(cx.tcx).load_macro_untracked(def_id, cx.sess()) {
- LoadedMacro::MacroDef(item_def, _) => {
- if let ast::ItemKind::MacroDef(ref def) = item_def.kind {
- let vis = cx.tcx.visibility(import_def_id.unwrap_or(def_id));
- clean::MacroItem(clean::Macro {
- source: utils::display_macro_source(cx, name, def, def_id, vis),
- })
- } else {
- unreachable!()
+ LoadedMacro::MacroDef(item_def, _) => match macro_kind {
+ MacroKind::Bang => {
+ if let ast::ItemKind::MacroDef(ref def) = item_def.kind {
+ let vis = cx.tcx.visibility(import_def_id.unwrap_or(def_id));
+ clean::MacroItem(clean::Macro {
+ source: utils::display_macro_source(cx, name, def, def_id, vis),
+ })
+ } else {
+ unreachable!()
+ }
}
- }
+ MacroKind::Derive | MacroKind::Attr => {
+ clean::ProcMacroItem(clean::ProcMacro { kind: macro_kind, helpers: Vec::new() })
+ }
+ },
LoadedMacro::ProcMacro(ext) => clean::ProcMacroItem(clean::ProcMacro {
kind: ext.macro_kind(),
helpers: ext.helper_attrs,
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 989e75cb8280b..6ceba1b1f8e22 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -909,6 +909,38 @@ fn clean_ty_generics<'tcx>(
}
}
+fn clean_proc_macro<'tcx>(
+ item: &hir::Item<'tcx>,
+ name: &mut Symbol,
+ kind: MacroKind,
+ cx: &mut DocContext<'tcx>,
+) -> ItemKind {
+ let attrs = cx.tcx.hir().attrs(item.hir_id());
+ if kind == MacroKind::Derive &&
+ let Some(derive_name) = attrs
+ .lists(sym::proc_macro_derive)
+ .find_map(|mi| mi.ident())
+ {
+ *name = derive_name.name;
+ }
+
+ let mut helpers = Vec::new();
+ for mi in attrs.lists(sym::proc_macro_derive) {
+ if !mi.has_name(sym::attributes) {
+ continue;
+ }
+
+ if let Some(list) = mi.meta_item_list() {
+ for inner_mi in list {
+ if let Some(ident) = inner_mi.ident() {
+ helpers.push(ident.name);
+ }
+ }
+ }
+ }
+ ProcMacroItem(ProcMacro { kind, helpers })
+}
+
fn clean_fn_or_proc_macro<'tcx>(
item: &hir::Item<'tcx>,
sig: &hir::FnSig<'tcx>,
@@ -930,31 +962,7 @@ fn clean_fn_or_proc_macro<'tcx>(
}
});
match macro_kind {
- Some(kind) => {
- if kind == MacroKind::Derive {
- *name = attrs
- .lists(sym::proc_macro_derive)
- .find_map(|mi| mi.ident())
- .expect("proc-macro derives require a name")
- .name;
- }
-
- let mut helpers = Vec::new();
- for mi in attrs.lists(sym::proc_macro_derive) {
- if !mi.has_name(sym::attributes) {
- continue;
- }
-
- if let Some(list) = mi.meta_item_list() {
- for inner_mi in list {
- if let Some(ident) = inner_mi.ident() {
- helpers.push(ident.name);
- }
- }
- }
- }
- ProcMacroItem(ProcMacro { kind, helpers })
- }
+ Some(kind) => clean_proc_macro(item, name, kind, cx),
None => {
let mut func = clean_function(cx, sig, generics, FunctionArgs::Body(body_id));
clean_fn_decl_legacy_const_generics(&mut func, attrs);
@@ -2247,16 +2255,17 @@ fn clean_maybe_renamed_item<'tcx>(
fields: variant_data.fields().iter().map(|x| clean_field(x, cx)).collect(),
}),
ItemKind::Impl(impl_) => return clean_impl(impl_, item.owner_id.def_id, cx),
- // proc macros can have a name set by attributes
- ItemKind::Fn(ref sig, generics, body_id) => {
- clean_fn_or_proc_macro(item, sig, generics, body_id, &mut name, cx)
- }
- ItemKind::Macro(ref macro_def, _) => {
+ ItemKind::Macro(ref macro_def, MacroKind::Bang) => {
let ty_vis = cx.tcx.visibility(def_id);
MacroItem(Macro {
source: display_macro_source(cx, name, macro_def, def_id, ty_vis),
})
}
+ ItemKind::Macro(_, macro_kind) => clean_proc_macro(item, &mut name, macro_kind, cx),
+ // proc macros can have a name set by attributes
+ ItemKind::Fn(ref sig, generics, body_id) => {
+ clean_fn_or_proc_macro(item, sig, generics, body_id, &mut name, cx)
+ }
ItemKind::Trait(_, _, generics, bounds, item_ids) => {
let items = item_ids
.iter()
diff --git a/tests/rustdoc/compiler-derive-proc-macro.rs b/tests/rustdoc/compiler-derive-proc-macro.rs
new file mode 100644
index 0000000000000..489ec924c1fcf
--- /dev/null
+++ b/tests/rustdoc/compiler-derive-proc-macro.rs
@@ -0,0 +1,15 @@
+// This test ensures that compiler builtin proc-macros are considered as such.
+
+#![crate_name = "foo"]
+
+// @has 'foo/index.html'
+// Each compiler builtin proc-macro has a trait equivalent so we should have
+// a trait section as well.
+// @count - '//*[@id="main-content"]//*[@class="small-section-header"]' 2
+// @has - '//*[@id="main-content"]//*[@class="small-section-header"]' 'Traits'
+// @has - '//*[@id="main-content"]//*[@class="small-section-header"]' 'Derive Macros'
+
+// Now checking the correct file is generated as well.
+// @has 'foo/derive.Clone.html'
+// @!has 'foo/macro.Clone.html'
+pub use std::clone::Clone;
diff --git a/tests/rustdoc/macro_pub_in_module.rs b/tests/rustdoc/macro_pub_in_module.rs
index 4fd85d6899401..42f760cff6a7c 100644
--- a/tests/rustdoc/macro_pub_in_module.rs
+++ b/tests/rustdoc/macro_pub_in_module.rs
@@ -7,8 +7,8 @@
#![crate_name = "krate"]
#![no_core]
- // @has external_crate/some_module/macro.external_macro.html
- // @!has external_crate/macro.external_macro.html
+// @has external_crate/some_module/macro.external_macro.html
+// @!has external_crate/macro.external_macro.html
extern crate external_crate;
pub mod inner {
@@ -16,13 +16,17 @@ pub mod inner {
// @!has krate/macro.raw_const.html
pub macro raw_const() {}
- // @has krate/inner/macro.test.html
+ // @has krate/inner/attr.test.html
// @!has krate/macro.test.html
+ // @!has krate/inner/macro.test.html
+ // @!has krate/attr.test.html
#[rustc_builtin_macro]
pub macro test($item:item) {}
- // @has krate/inner/macro.Clone.html
+ // @has krate/inner/derive.Clone.html
+ // @!has krate/inner/macro.Clone.html
// @!has krate/macro.Clone.html
+ // @!has krate/derive.Clone.html
#[rustc_builtin_macro]
pub macro Clone($item:item) {}
diff --git a/tests/ui/generator/non-static-is-unpin.rs b/tests/ui/generator/non-static-is-unpin.rs
index 96d0a8e283372..17e23f5bcd2fa 100644
--- a/tests/ui/generator/non-static-is-unpin.rs
+++ b/tests/ui/generator/non-static-is-unpin.rs
@@ -1,3 +1,5 @@
+// revisions: current next
+//[next] compile-flags: -Ztrait-solver=next
// run-pass
#![feature(generators, generator_trait)]
diff --git a/tests/ui/generator/static-not-unpin.stderr b/tests/ui/generator/static-not-unpin.current.stderr
similarity index 71%
rename from tests/ui/generator/static-not-unpin.stderr
rename to tests/ui/generator/static-not-unpin.current.stderr
index 7376116b3380a..ecd8ca60c6f2c 100644
--- a/tests/ui/generator/static-not-unpin.stderr
+++ b/tests/ui/generator/static-not-unpin.current.stderr
@@ -1,15 +1,15 @@
-error[E0277]: `[static generator@$DIR/static-not-unpin.rs:11:25: 11:34]` cannot be unpinned
- --> $DIR/static-not-unpin.rs:14:18
+error[E0277]: `[static generator@$DIR/static-not-unpin.rs:14:25: 14:34]` cannot be unpinned
+ --> $DIR/static-not-unpin.rs:17:18
|
LL | assert_unpin(generator);
- | ------------ ^^^^^^^^^ the trait `Unpin` is not implemented for `[static generator@$DIR/static-not-unpin.rs:11:25: 11:34]`
+ | ------------ ^^^^^^^^^ the trait `Unpin` is not implemented for `[static generator@$DIR/static-not-unpin.rs:14:25: 14:34]`
| |
| required by a bound introduced by this call
|
= note: consider using the `pin!` macro
consider using `Box::pin` if you need to access the pinned value outside of the current scope
note: required by a bound in `assert_unpin`
- --> $DIR/static-not-unpin.rs:7:20
+ --> $DIR/static-not-unpin.rs:10:20
|
LL | fn assert_unpin<T: Unpin>(_: T) {
| ^^^^^ required by this bound in `assert_unpin`
diff --git a/tests/ui/generator/static-not-unpin.next.stderr b/tests/ui/generator/static-not-unpin.next.stderr
new file mode 100644
index 0000000000000..ecd8ca60c6f2c
--- /dev/null
+++ b/tests/ui/generator/static-not-unpin.next.stderr
@@ -0,0 +1,19 @@
+error[E0277]: `[static generator@$DIR/static-not-unpin.rs:14:25: 14:34]` cannot be unpinned
+ --> $DIR/static-not-unpin.rs:17:18
+ |
+LL | assert_unpin(generator);
+ | ------------ ^^^^^^^^^ the trait `Unpin` is not implemented for `[static generator@$DIR/static-not-unpin.rs:14:25: 14:34]`
+ | |
+ | required by a bound introduced by this call
+ |
+ = note: consider using the `pin!` macro
+ consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required by a bound in `assert_unpin`
+ --> $DIR/static-not-unpin.rs:10:20
+ |
+LL | fn assert_unpin<T: Unpin>(_: T) {
+ | ^^^^^ required by this bound in `assert_unpin`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generator/static-not-unpin.rs b/tests/ui/generator/static-not-unpin.rs
index cfcb94737be6f..30d3f29187096 100644
--- a/tests/ui/generator/static-not-unpin.rs
+++ b/tests/ui/generator/static-not-unpin.rs
@@ -1,3 +1,6 @@
+// revisions: current next
+//[next] compile-flags: -Ztrait-solver=next
+
#![feature(generators)]
// normalize-stderr-test "std::pin::Unpin" -> "std::marker::Unpin"
diff --git a/tests/ui/generic-associated-types/bugs/issue-100013.stderr b/tests/ui/generic-associated-types/bugs/issue-100013.stderr
index 9db124a81e487..86dbad84d99d8 100644
--- a/tests/ui/generic-associated-types/bugs/issue-100013.stderr
+++ b/tests/ui/generic-associated-types/bugs/issue-100013.stderr
@@ -28,12 +28,12 @@ LL | | async {}.await; // a yield point
LL | | }
| |_____^
|
-note: the lifetime defined here...
+note: the lifetime `'b` defined here...
--> $DIR/issue-100013.rs:21:14
|
LL | fn call2<'a, 'b, I: FutureIterator>() -> impl Send {
| ^^
-note: ...must outlive the lifetime defined here
+note: ...must outlive the lifetime `'a` defined here
--> $DIR/issue-100013.rs:21:10
|
LL | fn call2<'a, 'b, I: FutureIterator>() -> impl Send {
@@ -62,12 +62,12 @@ LL | | async {}.await; // a yield point
LL | | }
| |_____^
|
-note: the lifetime defined here...
+note: the lifetime `'b` defined here...
--> $DIR/issue-100013.rs:28:18
|
LL | fn call3<'a: 'b, 'b, I: FutureIterator>() -> impl Send {
| ^^
-note: ...must outlive the lifetime defined here
+note: ...must outlive the lifetime `'a` defined here
--> $DIR/issue-100013.rs:28:10
|
LL | fn call3<'a: 'b, 'b, I: FutureIterator>() -> impl Send {
diff --git a/tests/ui/regions/issue-2718.rs b/tests/ui/regions/issue-2718.rs
deleted file mode 100644
index 6449337eea4e7..0000000000000
--- a/tests/ui/regions/issue-2718.rs
+++ /dev/null
@@ -1,327 +0,0 @@
-// run-pass
-#![allow(dead_code)]
-#![allow(unused_unsafe)]
-#![allow(unused_imports)]
-#![allow(non_camel_case_types)]
-
-pub type Task = isize;
-
-// tjc: I don't know why
-pub mod pipes {
- use self::state::{empty, full, blocked, terminated};
- use super::Task;
- use std::mem::{forget, transmute};
- use std::mem::{replace, swap};
- use std::mem;
- use std::thread;
- use std::marker::Send;
-
- pub struct Stuff<T> {
- state: state,
- blocked_task: Option<Task>,
- payload: Option<T>
- }
-
- #[derive(PartialEq, Debug)]
- #[repr(isize)]
- pub enum state {
- empty,
- full,
- blocked,
- terminated
- }
-
- pub struct packet<T> {
- state: state,
- blocked_task: Option<Task>,
- payload: Option<T>
- }
-
- unsafe impl<T:Send> Send for packet<T> {}
-
- pub fn packet<T:Send>() -> *const packet<T> {
- unsafe {
- let p: *const packet<T> = mem::transmute(Box::new(Stuff{
- state: empty,
- blocked_task: None::<Task>,
- payload: None::<T>
- }));
- p
- }
- }
-
- mod rusti {
- pub fn atomic_xchg(_dst: &mut isize, _src: isize) -> isize { panic!(); }
- pub fn atomic_xchg_acq(_dst: &mut isize, _src: isize) -> isize { panic!(); }
- pub fn atomic_xchg_rel(_dst: &mut isize, _src: isize) -> isize { panic!(); }
- }
-
- // We should consider moving this to ::std::unsafe, although I
- // suspect graydon would want us to use void pointers instead.
- pub unsafe fn uniquify<T>(x: *const T) -> Box<T> {
- mem::transmute(x)
- }
-
- pub fn swap_state_acq(dst: &mut state, src: state) -> state {
- unsafe {
- transmute(rusti::atomic_xchg_acq(transmute(dst), src as isize))
- }
- }
-
- pub fn swap_state_rel(dst: &mut state, src: state) -> state {
- unsafe {
- transmute(rusti::atomic_xchg_rel(transmute(dst), src as isize))
- }
- }
-
- pub fn send<T:Send>(mut p: send_packet<T>, payload: T) {
- let p = p.unwrap();
- let mut p = unsafe { uniquify(p) };
- assert!((*p).payload.is_none());
- (*p).payload = Some(payload);
- let old_state = swap_state_rel(&mut (*p).state, full);
- match old_state {
- empty => {
- // Yay, fastpath.
-
- // The receiver will eventually clean this up.
- unsafe { forget(p); }
- }
- full => { panic!("duplicate send") }
- blocked => {
-
- // The receiver will eventually clean this up.
- unsafe { forget(p); }
- }
- terminated => {
- // The receiver will never receive this. Rely on drop_glue
- // to clean everything up.
- }
- }
- }
-
- pub fn recv<T:Send>(mut p: recv_packet<T>) -> Option<T> {
- let p = p.unwrap();
- let mut p = unsafe { uniquify(p) };
- loop {
- let old_state = swap_state_acq(&mut (*p).state,
- blocked);
- match old_state {
- empty | blocked => { thread::yield_now(); }
- full => {
- let payload = replace(&mut p.payload, None);
- return Some(payload.unwrap())
- }
- terminated => {
- assert_eq!(old_state, terminated);
- return None;
- }
- }
- }
- }
-
- pub fn sender_terminate<T:Send>(p: *const packet<T>) {
- let mut p = unsafe { uniquify(p) };
- match swap_state_rel(&mut (*p).state, terminated) {
- empty | blocked => {
- // The receiver will eventually clean up.
- unsafe { forget(p) }
- }
- full => {
- // This is impossible
- panic!("you dun goofed")
- }
- terminated => {
- // I have to clean up, use drop_glue
- }
- }
- }
-
- pub fn receiver_terminate<T:Send>(p: *const packet<T>) {
- let mut p = unsafe { uniquify(p) };
- match swap_state_rel(&mut (*p).state, terminated) {
- empty => {
- // the sender will clean up
- unsafe { forget(p) }
- }
- blocked => {
- // this shouldn't happen.
- panic!("terminating a blocked packet")
- }
- terminated | full => {
- // I have to clean up, use drop_glue
- }
- }
- }
-
- pub struct send_packet<T:Send> {
- p: Option<*const packet<T>>,
- }
-
- impl<T:Send> Drop for send_packet<T> {
- fn drop(&mut self) {
- unsafe {
- if self.p != None {
- let self_p: &mut Option<*const packet<T>> =
- mem::transmute(&mut self.p);
- let p = replace(self_p, None);
- sender_terminate(p.unwrap())
- }
- }
- }
- }
-
- impl<T:Send> send_packet<T> {
- pub fn unwrap(&mut self) -> *const packet<T> {
- replace(&mut self.p, None).unwrap()
- }
- }
-
- pub fn send_packet<T:Send>(p: *const packet<T>) -> send_packet<T> {
- send_packet {
- p: Some(p)
- }
- }
-
- pub struct recv_packet<T:Send> {
- p: Option<*const packet<T>>,
- }
-
- impl<T:Send> Drop for recv_packet<T> {
- fn drop(&mut self) {
- unsafe {
- if self.p != None {
- let self_p: &mut Option<*const packet<T>> =
- mem::transmute(&mut self.p);
- let p = replace(self_p, None);
- receiver_terminate(p.unwrap())
- }
- }
- }
- }
-
- impl<T:Send> recv_packet<T> {
- pub fn unwrap(&mut self) -> *const packet<T> {
- replace(&mut self.p, None).unwrap()
- }
- }
-
- pub fn recv_packet<T:Send>(p: *const packet<T>) -> recv_packet<T> {
- recv_packet {
- p: Some(p)
- }
- }
-
- pub fn entangle<T:Send>() -> (send_packet<T>, recv_packet<T>) {
- let p = packet();
- (send_packet(p), recv_packet(p))
- }
-}
-
-pub mod pingpong {
- use std::mem;
-
- pub struct ping(::pipes::send_packet<pong>);
-
- unsafe impl Send for ping {}
-
- pub struct pong(::pipes::send_packet<ping>);
-
- unsafe impl Send for pong {}
-
- pub fn liberate_ping(p: ping) -> ::pipes::send_packet<pong> {
- unsafe {
- let _addr : *const ::pipes::send_packet<pong> = match &p {
- &ping(ref x) => { mem::transmute(x) }
- };
- panic!()
- }
- }
-
- pub fn liberate_pong(p: pong) -> ::pipes::send_packet<ping> {
- unsafe {
- let _addr : *const ::pipes::send_packet<ping> = match &p {
- &pong(ref x) => { mem::transmute(x) }
- };
- panic!()
- }
- }
-
- pub fn init() -> (client::ping, server::ping) {
- ::pipes::entangle()
- }
-
- pub mod client {
- use pingpong;
-
- pub type ping = ::pipes::send_packet<pingpong::ping>;
- pub type pong = ::pipes::recv_packet<pingpong::pong>;
-
- pub fn do_ping(c: ping) -> pong {
- let (sp, rp) = ::pipes::entangle();
-
- ::pipes::send(c, pingpong::ping(sp));
- rp
- }
-
- pub fn do_pong(c: pong) -> (ping, ()) {
- let packet = ::pipes::recv(c);
- if packet.is_none() {
- panic!("sender closed the connection")
- }
- (pingpong::liberate_pong(packet.unwrap()), ())
- }
- }
-
- pub mod server {
- use pingpong;
-
- pub type ping = ::pipes::recv_packet<pingpong::ping>;
- pub type pong = ::pipes::send_packet<pingpong::pong>;
-
- pub fn do_ping(c: ping) -> (pong, ()) {
- let packet = ::pipes::recv(c);
- if packet.is_none() {
- panic!("sender closed the connection")
- }
- (pingpong::liberate_ping(packet.unwrap()), ())
- }
-
- pub fn do_pong(c: pong) -> ping {
- let (sp, rp) = ::pipes::entangle();
- ::pipes::send(c, pingpong::pong(sp));
- rp
- }
- }
-}
-
-fn client(chan: pingpong::client::ping) {
- let chan = pingpong::client::do_ping(chan);
- println!("Sent ping");
- let (_chan, _data) = pingpong::client::do_pong(chan);
- println!("Received pong");
-}
-
-fn server(chan: pingpong::server::ping) {
- let (chan, _data) = pingpong::server::do_ping(chan);
- println!("Received ping");
- let _chan = pingpong::server::do_pong(chan);
- println!("Sent pong");
-}
-
-pub fn main() {
- /*
-// Commented out because of option::get error
-
- let (client_, server_) = pingpong::init();
-
- task::spawn {|client_|
- let client__ = client_.take();
- client(client__);
- };
- task::spawn {|server_|
- let server__ = server_.take();
- server(server_ˊ);
- };
- */
-}
diff --git a/tests/ui/traits/new-solver/iter-filter-projection.rs b/tests/ui/traits/new-solver/iter-filter-projection.rs
new file mode 100644
index 0000000000000..8fb62323aa5a7
--- /dev/null
+++ b/tests/ui/traits/new-solver/iter-filter-projection.rs
@@ -0,0 +1,12 @@
+// compile-flags: -Ztrait-solver=next
+// check-pass
+
+use std::{iter, slice};
+
+struct Attr;
+
+fn test<'a, T: Iterator<Item = &'a Attr>>() {}
+
+fn main() {
+ test::<iter::Filter<slice::Iter<'_, Attr>, fn(&&Attr) -> bool>>();
+}
diff --git a/tests/ui/transmutability/arrays/should_require_well_defined_layout.stderr b/tests/ui/transmutability/arrays/should_require_well_defined_layout.stderr
index 164e88ede202f..1a0a5d3ae9462 100644
--- a/tests/ui/transmutability/arrays/should_require_well_defined_layout.stderr
+++ b/tests/ui/transmutability/arrays/should_require_well_defined_layout.stderr
@@ -1,10 +1,9 @@
-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:26:52
|
LL | assert::is_maybe_transmutable::<repr_rust, ()>();
- | ^^ `[String; 0]` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
+ | ^^ `[String; 0]` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
@@ -20,13 +19,12 @@ 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:27:47
|
LL | assert::is_maybe_transmutable::<u128, repr_rust>();
- | ^^^^^^^^^ `u128` cannot be safely transmuted into `[String; 0]` in the defining scope of `assert::Context`.
+ | ^^^^^^^^^ `[String; 0]` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
@@ -42,13 +40,12 @@ 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:32:52
|
LL | assert::is_maybe_transmutable::<repr_rust, ()>();
- | ^^ `[String; 1]` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
+ | ^^ `[String; 1]` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
@@ -64,13 +61,12 @@ 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:33:47
|
LL | assert::is_maybe_transmutable::<u128, repr_rust>();
- | ^^^^^^^^^ `u128` cannot be safely transmuted into `[String; 1]` in the defining scope of `assert::Context`.
+ | ^^^^^^^^^ `[String; 1]` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
@@ -86,13 +82,12 @@ 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:38:52
|
LL | assert::is_maybe_transmutable::<repr_rust, ()>();
- | ^^ `[String; 2]` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
+ | ^^ `[String; 2]` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
@@ -108,13 +103,12 @@ 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:39:47
|
LL | assert::is_maybe_transmutable::<u128, repr_rust>();
- | ^^^^^^^^^ `u128` cannot be safely transmuted into `[String; 2]` in the defining scope of `assert::Context`.
+ | ^^^^^^^^^ `[String; 2]` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
diff --git a/tests/ui/transmutability/enums/repr/primitive_reprs_should_have_correct_length.stderr b/tests/ui/transmutability/enums/repr/primitive_reprs_should_have_correct_length.stderr
index 0f0f77f168372..9877a6606a9fa 100644
--- a/tests/ui/transmutability/enums/repr/primitive_reprs_should_have_correct_length.stderr
+++ b/tests/ui/transmutability/enums/repr/primitive_reprs_should_have_correct_length.stderr
@@ -1,10 +1,9 @@
-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:48:44
|
LL | assert::is_transmutable::<Smaller, Current, Context>();
- | ^^^^^^^ `Zst` cannot be safely transmuted into `V0i8` in the defining scope of `n8::Context`.
+ | ^^^^^^^ The size of `Zst` is smaller than the size of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -21,13 +20,12 @@ 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:50:44
|
LL | assert::is_transmutable::<Current, Larger, Context>();
- | ^^^^^^ `V0i8` cannot be safely transmuted into `u16` in the defining scope of `n8::Context`.
+ | ^^^^^^ The size of `V0i8` is smaller than the size of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -44,13 +42,12 @@ 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:56:44
|
LL | assert::is_transmutable::<Smaller, Current, Context>();
- | ^^^^^^^ `Zst` cannot be safely transmuted into `V0u8` in the defining scope of `n8::Context`.
+ | ^^^^^^^ The size of `Zst` is smaller than the size of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -67,13 +64,12 @@ 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:58:44
|
LL | assert::is_transmutable::<Current, Larger, Context>();
- | ^^^^^^ `V0u8` cannot be safely transmuted into `u16` in the defining scope of `n8::Context`.
+ | ^^^^^^ The size of `V0u8` is smaller than the size of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -90,13 +86,12 @@ 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:72:44
|
LL | assert::is_transmutable::<Smaller, Current, Context>();
- | ^^^^^^^ `u8` cannot be safely transmuted into `V0i16` in the defining scope of `n16::Context`.
+ | ^^^^^^^ At least one value of `u8` isn't a bit-valid value of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -113,13 +108,12 @@ 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:74:44
|
LL | assert::is_transmutable::<Current, Larger, Context>();
- | ^^^^^^ `V0i16` cannot be safely transmuted into `u32` in the defining scope of `n16::Context`.
+ | ^^^^^^ The size of `V0i16` is smaller than the size of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -136,13 +130,12 @@ 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:80:44
|
LL | assert::is_transmutable::<Smaller, Current, Context>();
- | ^^^^^^^ `u8` cannot be safely transmuted into `V0u16` in the defining scope of `n16::Context`.
+ | ^^^^^^^ At least one value of `u8` isn't a bit-valid value of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -159,13 +152,12 @@ 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:82:44
|
LL | assert::is_transmutable::<Current, Larger, Context>();
- | ^^^^^^ `V0u16` cannot be safely transmuted into `u32` in the defining scope of `n16::Context`.
+ | ^^^^^^ The size of `V0u16` is smaller than the size of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -182,13 +174,12 @@ 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:96:44
|
LL | assert::is_transmutable::<Smaller, Current, Context>();
- | ^^^^^^^ `u16` cannot be safely transmuted into `V0i32` in the defining scope of `n32::Context`.
+ | ^^^^^^^ At least one value of `u16` isn't a bit-valid value of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -205,13 +196,12 @@ 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:98:44
|
LL | assert::is_transmutable::<Current, Larger, Context>();
- | ^^^^^^ `V0i32` cannot be safely transmuted into `u64` in the defining scope of `n32::Context`.
+ | ^^^^^^ The size of `V0i32` is smaller than the size of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -228,13 +218,12 @@ 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:104:44
|
LL | assert::is_transmutable::<Smaller, Current, Context>();
- | ^^^^^^^ `u16` cannot be safely transmuted into `V0u32` in the defining scope of `n32::Context`.
+ | ^^^^^^^ At least one value of `u16` isn't a bit-valid value of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -251,13 +240,12 @@ 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:106:44
|
LL | assert::is_transmutable::<Current, Larger, Context>();
- | ^^^^^^ `V0u32` cannot be safely transmuted into `u64` in the defining scope of `n32::Context`.
+ | ^^^^^^ The size of `V0u32` is smaller than the size of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -274,13 +262,12 @@ 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:120:44
|
LL | assert::is_transmutable::<Smaller, Current, Context>();
- | ^^^^^^^ `u32` cannot be safely transmuted into `V0i64` in the defining scope of `n64::Context`.
+ | ^^^^^^^ At least one value of `u32` isn't a bit-valid value of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -297,13 +284,12 @@ 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:122:44
|
LL | assert::is_transmutable::<Current, Larger, Context>();
- | ^^^^^^ `V0i64` cannot be safely transmuted into `u128` in the defining scope of `n64::Context`.
+ | ^^^^^^ The size of `V0i64` is smaller than the size of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -320,13 +306,12 @@ 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:128:44
|
LL | assert::is_transmutable::<Smaller, Current, Context>();
- | ^^^^^^^ `u32` cannot be safely transmuted into `V0u64` in the defining scope of `n64::Context`.
+ | ^^^^^^^ At least one value of `u32` isn't a bit-valid value of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -343,13 +328,12 @@ 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:130:44
|
LL | assert::is_transmutable::<Current, Larger, Context>();
- | ^^^^^^ `V0u64` cannot be safely transmuted into `u128` in the defining scope of `n64::Context`.
+ | ^^^^^^ The size of `V0u64` is smaller than the size of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -366,13 +350,12 @@ 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:144:44
|
LL | assert::is_transmutable::<Smaller, Current, Context>();
- | ^^^^^^^ `u8` cannot be safely transmuted into `V0isize` in the defining scope of `nsize::Context`.
+ | ^^^^^^^ At least one value of `u8` isn't a bit-valid value of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -389,13 +372,12 @@ 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:146:44
|
LL | assert::is_transmutable::<Current, Larger, Context>();
- | ^^^^^^ `V0isize` cannot be safely transmuted into `[usize; 2]` in the defining scope of `nsize::Context`.
+ | ^^^^^^ The size of `V0isize` is smaller than the size of `[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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -412,13 +394,12 @@ 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:152:44
|
LL | assert::is_transmutable::<Smaller, Current, Context>();
- | ^^^^^^^ `u8` cannot be safely transmuted into `V0usize` in the defining scope of `nsize::Context`.
+ | ^^^^^^^ At least one value of `u8` isn't a bit-valid value of `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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
@@ -435,13 +416,12 @@ 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:154:44
|
LL | assert::is_transmutable::<Current, Larger, Context>();
- | ^^^^^^ `V0usize` cannot be safely transmuted into `[usize; 2]` in the defining scope of `nsize::Context`.
+ | ^^^^^^ The size of `V0usize` is smaller than the size of `[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`
--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
|
diff --git a/tests/ui/transmutability/enums/repr/should_require_well_defined_layout.stderr b/tests/ui/transmutability/enums/repr/should_require_well_defined_layout.stderr
index d456a746f5ebd..1612b6b3661ef 100644
--- a/tests/ui/transmutability/enums/repr/should_require_well_defined_layout.stderr
+++ b/tests/ui/transmutability/enums/repr/should_require_well_defined_layout.stderr
@@ -1,10 +1,9 @@
-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:28:52
|
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` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:14:14
|
@@ -21,13 +20,12 @@ 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:29:47
|
LL | assert::is_maybe_transmutable::<u128, repr_rust>();
- | ^^^^^^^^^ `u128` cannot be safely transmuted into `void::repr_rust` in the defining scope of `assert::Context`.
+ | ^^^^^^^^^ `void::repr_rust` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:14:14
|
@@ -44,13 +42,12 @@ 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:34:52
|
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` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:14:14
|
@@ -67,13 +64,12 @@ 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:35:47
|
LL | assert::is_maybe_transmutable::<u128, repr_rust>();
- | ^^^^^^^^^ `u128` cannot be safely transmuted into `singleton::repr_rust` in the defining scope of `assert::Context`.
+ | ^^^^^^^^^ `singleton::repr_rust` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:14:14
|
@@ -90,13 +86,12 @@ 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:40:52
|
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` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:14:14
|
@@ -113,13 +108,12 @@ 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:41:47
|
LL | assert::is_maybe_transmutable::<u128, repr_rust>();
- | ^^^^^^^^^ `u128` cannot be safely transmuted into `duplex::repr_rust` in the defining scope of `assert::Context`.
+ | ^^^^^^^^^ `duplex::repr_rust` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:14:14
|
diff --git a/tests/ui/transmutability/enums/should_pad_variants.stderr b/tests/ui/transmutability/enums/should_pad_variants.stderr
index f4988239df943..bfbef8b25fcf4 100644
--- a/tests/ui/transmutability/enums/should_pad_variants.stderr
+++ b/tests/ui/transmutability/enums/should_pad_variants.stderr
@@ -1,10 +1,9 @@
-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:44:36
|
LL | assert::is_transmutable::<Src, Dst, Context>();
- | ^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `should_pad_variants::Context`.
+ | ^^^ The size of `Src` is smaller than the size of `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`
--> $DIR/should_pad_variants.rs:13:14
|
diff --git a/tests/ui/transmutability/enums/should_respect_endianness.stderr b/tests/ui/transmutability/enums/should_respect_endianness.stderr
index 350583b0b8515..e59301a8ce9e2 100644
--- a/tests/ui/transmutability/enums/should_respect_endianness.stderr
+++ b/tests/ui/transmutability/enums/should_respect_endianness.stderr
@@ -1,10 +1,9 @@
-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:36:36
|
LL | assert::is_transmutable::<Src, Unexpected>();
- | ^^^^^^^^^^ `Src` cannot be safely transmuted into `Unexpected` in the defining scope of `assert::Context`.
+ | ^^^^^^^^^^ At least one value of `Src` isn't a bit-valid value of `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`
--> $DIR/should_respect_endianness.rs:14:14
|
diff --git a/tests/ui/transmutability/primitives/bool.current.stderr b/tests/ui/transmutability/primitives/bool.current.stderr
index 999302224eebf..47c8438a251c2 100644
--- a/tests/ui/transmutability/primitives/bool.current.stderr
+++ b/tests/ui/transmutability/primitives/bool.current.stderr
@@ -1,10 +1,9 @@
-error[E0277]: `u8` cannot be safely transmuted into `bool` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `bool` in the defining scope of `assert::Context`
--> $DIR/bool.rs:24:35
|
LL | assert::is_transmutable::<u8, bool>();
- | ^^^^ `u8` cannot be safely transmuted into `bool` in the defining scope of `assert::Context`.
+ | ^^^^ At least one value of `u8` isn't a bit-valid value of `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`
--> $DIR/bool.rs:14:14
|
diff --git a/tests/ui/transmutability/primitives/bool.next.stderr b/tests/ui/transmutability/primitives/bool.next.stderr
index 999302224eebf..47c8438a251c2 100644
--- a/tests/ui/transmutability/primitives/bool.next.stderr
+++ b/tests/ui/transmutability/primitives/bool.next.stderr
@@ -1,10 +1,9 @@
-error[E0277]: `u8` cannot be safely transmuted into `bool` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `bool` in the defining scope of `assert::Context`
--> $DIR/bool.rs:24:35
|
LL | assert::is_transmutable::<u8, bool>();
- | ^^^^ `u8` cannot be safely transmuted into `bool` in the defining scope of `assert::Context`.
+ | ^^^^ At least one value of `u8` isn't a bit-valid value of `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`
--> $DIR/bool.rs:14:14
|
diff --git a/tests/ui/transmutability/primitives/numbers.current.stderr b/tests/ui/transmutability/primitives/numbers.current.stderr
index bbf1f1669995e..d12e172971c38 100644
--- a/tests/ui/transmutability/primitives/numbers.current.stderr
+++ b/tests/ui/transmutability/primitives/numbers.current.stderr
@@ -1,10 +1,9 @@
-error[E0277]: `i8` cannot be safely transmuted into `i16` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `i16` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:65:40
|
LL | assert::is_transmutable::< i8, i16>();
- | ^^^ `i8` cannot be safely transmuted into `i16` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i8` is smaller than the size of `i16`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i16`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -14,13 +13,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `u16` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `u16` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:66:40
|
LL | assert::is_transmutable::< i8, u16>();
- | ^^^ `i8` cannot be safely transmuted into `u16` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i8` is smaller than the size of `u16`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u16`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -30,13 +28,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:67:40
|
LL | assert::is_transmutable::< i8, i32>();
- | ^^^ `i8` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i8` is smaller than the size of `i32`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -46,13 +43,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:68:40
|
LL | assert::is_transmutable::< i8, f32>();
- | ^^^ `i8` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i8` is smaller than the size of `f32`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -62,13 +58,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:69:40
|
LL | assert::is_transmutable::< i8, u32>();
- | ^^^ `i8` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i8` is smaller than the size of `u32`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -78,13 +73,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:70:40
|
LL | assert::is_transmutable::< i8, u64>();
- | ^^^ `i8` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i8` is smaller than the size of `u64`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -94,13 +88,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:71:40
|
LL | assert::is_transmutable::< i8, i64>();
- | ^^^ `i8` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i8` is smaller than the size of `i64`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -110,13 +103,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:72:40
|
LL | assert::is_transmutable::< i8, f64>();
- | ^^^ `i8` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i8` is smaller than the size of `f64`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -126,13 +118,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:73:39
|
LL | assert::is_transmutable::< i8, u128>();
- | ^^^^ `i8` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `i8` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -142,13 +133,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:74:39
|
LL | assert::is_transmutable::< i8, i128>();
- | ^^^^ `i8` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `i8` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -158,13 +148,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `i16` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `i16` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:76:40
|
LL | assert::is_transmutable::< u8, i16>();
- | ^^^ `u8` cannot be safely transmuted into `i16` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u8` is smaller than the size of `i16`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i16`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -174,13 +163,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `u16` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `u16` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:77:40
|
LL | assert::is_transmutable::< u8, u16>();
- | ^^^ `u8` cannot be safely transmuted into `u16` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u8` is smaller than the size of `u16`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u16`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -190,13 +178,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:78:40
|
LL | assert::is_transmutable::< u8, i32>();
- | ^^^ `u8` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u8` is smaller than the size of `i32`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -206,13 +193,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:79:40
|
LL | assert::is_transmutable::< u8, f32>();
- | ^^^ `u8` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u8` is smaller than the size of `f32`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -222,13 +208,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:80:40
|
LL | assert::is_transmutable::< u8, u32>();
- | ^^^ `u8` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u8` is smaller than the size of `u32`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -238,13 +223,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:81:40
|
LL | assert::is_transmutable::< u8, u64>();
- | ^^^ `u8` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u8` is smaller than the size of `u64`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -254,13 +238,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:82:40
|
LL | assert::is_transmutable::< u8, i64>();
- | ^^^ `u8` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u8` is smaller than the size of `i64`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -270,13 +253,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:83:40
|
LL | assert::is_transmutable::< u8, f64>();
- | ^^^ `u8` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u8` is smaller than the size of `f64`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -286,13 +268,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:84:39
|
LL | assert::is_transmutable::< u8, u128>();
- | ^^^^ `u8` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `u8` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -302,13 +283,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:85:39
|
LL | assert::is_transmutable::< u8, i128>();
- | ^^^^ `u8` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `u8` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -318,13 +298,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i16` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
+error[E0277]: `i16` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:87:40
|
LL | assert::is_transmutable::< i16, i32>();
- | ^^^ `i16` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i16` is smaller than the size of `i32`
|
- = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -334,13 +313,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i16` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
+error[E0277]: `i16` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:88:40
|
LL | assert::is_transmutable::< i16, f32>();
- | ^^^ `i16` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i16` is smaller than the size of `f32`
|
- = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -350,13 +328,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i16` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
+error[E0277]: `i16` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:89:40
|
LL | assert::is_transmutable::< i16, u32>();
- | ^^^ `i16` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i16` is smaller than the size of `u32`
|
- = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -366,13 +343,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i16` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+error[E0277]: `i16` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:90:40
|
LL | assert::is_transmutable::< i16, u64>();
- | ^^^ `i16` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i16` is smaller than the size of `u64`
|
- = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -382,13 +358,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i16` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+error[E0277]: `i16` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:91:40
|
LL | assert::is_transmutable::< i16, i64>();
- | ^^^ `i16` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i16` is smaller than the size of `i64`
|
- = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -398,13 +373,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i16` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+error[E0277]: `i16` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:92:40
|
LL | assert::is_transmutable::< i16, f64>();
- | ^^^ `i16` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i16` is smaller than the size of `f64`
|
- = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -414,13 +388,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i16` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `i16` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:93:39
|
LL | assert::is_transmutable::< i16, u128>();
- | ^^^^ `i16` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `i16` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -430,13 +403,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i16` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `i16` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:94:39
|
LL | assert::is_transmutable::< i16, i128>();
- | ^^^^ `i16` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `i16` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -446,13 +418,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u16` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
+error[E0277]: `u16` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:96:40
|
LL | assert::is_transmutable::< u16, i32>();
- | ^^^ `u16` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u16` is smaller than the size of `i32`
|
- = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -462,13 +433,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u16` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
+error[E0277]: `u16` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:97:40
|
LL | assert::is_transmutable::< u16, f32>();
- | ^^^ `u16` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u16` is smaller than the size of `f32`
|
- = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -478,13 +448,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u16` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
+error[E0277]: `u16` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:98:40
|
LL | assert::is_transmutable::< u16, u32>();
- | ^^^ `u16` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u16` is smaller than the size of `u32`
|
- = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -494,13 +463,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u16` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+error[E0277]: `u16` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:99:40
|
LL | assert::is_transmutable::< u16, u64>();
- | ^^^ `u16` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u16` is smaller than the size of `u64`
|
- = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -510,13 +478,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u16` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+error[E0277]: `u16` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:100:40
|
LL | assert::is_transmutable::< u16, i64>();
- | ^^^ `u16` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u16` is smaller than the size of `i64`
|
- = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -526,13 +493,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u16` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+error[E0277]: `u16` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:101:40
|
LL | assert::is_transmutable::< u16, f64>();
- | ^^^ `u16` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u16` is smaller than the size of `f64`
|
- = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -542,13 +508,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u16` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `u16` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:102:39
|
LL | assert::is_transmutable::< u16, u128>();
- | ^^^^ `u16` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `u16` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -558,13 +523,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u16` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `u16` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:103:39
|
LL | assert::is_transmutable::< u16, i128>();
- | ^^^^ `u16` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `u16` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -574,13 +538,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+error[E0277]: `i32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:105:40
|
LL | assert::is_transmutable::< i32, u64>();
- | ^^^ `i32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i32` is smaller than the size of `u64`
|
- = help: the trait `BikeshedIntrinsicFrom<i32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -590,13 +553,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+error[E0277]: `i32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:106:40
|
LL | assert::is_transmutable::< i32, i64>();
- | ^^^ `i32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i32` is smaller than the size of `i64`
|
- = help: the trait `BikeshedIntrinsicFrom<i32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -606,13 +568,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+error[E0277]: `i32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:107:40
|
LL | assert::is_transmutable::< i32, f64>();
- | ^^^ `i32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i32` is smaller than the size of `f64`
|
- = help: the trait `BikeshedIntrinsicFrom<i32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -622,13 +583,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `i32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:108:39
|
LL | assert::is_transmutable::< i32, u128>();
- | ^^^^ `i32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `i32` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<i32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -638,13 +598,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `i32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:109:39
|
LL | assert::is_transmutable::< i32, i128>();
- | ^^^^ `i32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `i32` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<i32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -654,13 +613,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `f32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+error[E0277]: `f32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:111:40
|
LL | assert::is_transmutable::< f32, u64>();
- | ^^^ `f32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `f32` is smaller than the size of `u64`
|
- = help: the trait `BikeshedIntrinsicFrom<f32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -670,13 +628,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `f32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+error[E0277]: `f32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:112:40
|
LL | assert::is_transmutable::< f32, i64>();
- | ^^^ `f32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `f32` is smaller than the size of `i64`
|
- = help: the trait `BikeshedIntrinsicFrom<f32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -686,13 +643,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `f32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+error[E0277]: `f32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:113:40
|
LL | assert::is_transmutable::< f32, f64>();
- | ^^^ `f32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `f32` is smaller than the size of `f64`
|
- = help: the trait `BikeshedIntrinsicFrom<f32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -702,13 +658,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `f32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `f32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:114:39
|
LL | assert::is_transmutable::< f32, u128>();
- | ^^^^ `f32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `f32` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<f32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -718,13 +673,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `f32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `f32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:115:39
|
LL | assert::is_transmutable::< f32, i128>();
- | ^^^^ `f32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `f32` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<f32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -734,13 +688,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+error[E0277]: `u32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:117:40
|
LL | assert::is_transmutable::< u32, u64>();
- | ^^^ `u32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u32` is smaller than the size of `u64`
|
- = help: the trait `BikeshedIntrinsicFrom<u32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -750,13 +703,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+error[E0277]: `u32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:118:40
|
LL | assert::is_transmutable::< u32, i64>();
- | ^^^ `u32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u32` is smaller than the size of `i64`
|
- = help: the trait `BikeshedIntrinsicFrom<u32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -766,13 +718,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+error[E0277]: `u32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:119:40
|
LL | assert::is_transmutable::< u32, f64>();
- | ^^^ `u32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u32` is smaller than the size of `f64`
|
- = help: the trait `BikeshedIntrinsicFrom<u32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -782,13 +733,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `u32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:120:39
|
LL | assert::is_transmutable::< u32, u128>();
- | ^^^^ `u32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `u32` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<u32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -798,13 +748,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `u32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:121:39
|
LL | assert::is_transmutable::< u32, i128>();
- | ^^^^ `u32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `u32` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<u32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -814,13 +763,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `u64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:123:39
|
LL | assert::is_transmutable::< u64, u128>();
- | ^^^^ `u64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `u64` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<u64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -830,13 +778,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `u64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:124:39
|
LL | assert::is_transmutable::< u64, i128>();
- | ^^^^ `u64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `u64` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<u64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -846,13 +793,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `i64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:126:39
|
LL | assert::is_transmutable::< i64, u128>();
- | ^^^^ `i64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `i64` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<i64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -862,13 +808,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `i64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:127:39
|
LL | assert::is_transmutable::< i64, i128>();
- | ^^^^ `i64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `i64` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<i64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -878,13 +823,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `f64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `f64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:129:39
|
LL | assert::is_transmutable::< f64, u128>();
- | ^^^^ `f64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `f64` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<f64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -894,13 +838,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `f64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `f64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:130:39
|
LL | assert::is_transmutable::< f64, i128>();
- | ^^^^ `f64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `f64` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<f64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
diff --git a/tests/ui/transmutability/primitives/numbers.next.stderr b/tests/ui/transmutability/primitives/numbers.next.stderr
index bbf1f1669995e..d12e172971c38 100644
--- a/tests/ui/transmutability/primitives/numbers.next.stderr
+++ b/tests/ui/transmutability/primitives/numbers.next.stderr
@@ -1,10 +1,9 @@
-error[E0277]: `i8` cannot be safely transmuted into `i16` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `i16` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:65:40
|
LL | assert::is_transmutable::< i8, i16>();
- | ^^^ `i8` cannot be safely transmuted into `i16` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i8` is smaller than the size of `i16`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i16`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -14,13 +13,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `u16` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `u16` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:66:40
|
LL | assert::is_transmutable::< i8, u16>();
- | ^^^ `i8` cannot be safely transmuted into `u16` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i8` is smaller than the size of `u16`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u16`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -30,13 +28,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:67:40
|
LL | assert::is_transmutable::< i8, i32>();
- | ^^^ `i8` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i8` is smaller than the size of `i32`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -46,13 +43,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:68:40
|
LL | assert::is_transmutable::< i8, f32>();
- | ^^^ `i8` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i8` is smaller than the size of `f32`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -62,13 +58,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:69:40
|
LL | assert::is_transmutable::< i8, u32>();
- | ^^^ `i8` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i8` is smaller than the size of `u32`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -78,13 +73,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:70:40
|
LL | assert::is_transmutable::< i8, u64>();
- | ^^^ `i8` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i8` is smaller than the size of `u64`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -94,13 +88,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:71:40
|
LL | assert::is_transmutable::< i8, i64>();
- | ^^^ `i8` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i8` is smaller than the size of `i64`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -110,13 +103,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:72:40
|
LL | assert::is_transmutable::< i8, f64>();
- | ^^^ `i8` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i8` is smaller than the size of `f64`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -126,13 +118,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:73:39
|
LL | assert::is_transmutable::< i8, u128>();
- | ^^^^ `i8` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `i8` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -142,13 +133,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i8` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `i8` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:74:39
|
LL | assert::is_transmutable::< i8, i128>();
- | ^^^^ `i8` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `i8` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -158,13 +148,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `i16` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `i16` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:76:40
|
LL | assert::is_transmutable::< u8, i16>();
- | ^^^ `u8` cannot be safely transmuted into `i16` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u8` is smaller than the size of `i16`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i16`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -174,13 +163,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `u16` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `u16` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:77:40
|
LL | assert::is_transmutable::< u8, u16>();
- | ^^^ `u8` cannot be safely transmuted into `u16` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u8` is smaller than the size of `u16`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u16`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -190,13 +178,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:78:40
|
LL | assert::is_transmutable::< u8, i32>();
- | ^^^ `u8` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u8` is smaller than the size of `i32`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -206,13 +193,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:79:40
|
LL | assert::is_transmutable::< u8, f32>();
- | ^^^ `u8` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u8` is smaller than the size of `f32`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -222,13 +208,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:80:40
|
LL | assert::is_transmutable::< u8, u32>();
- | ^^^ `u8` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u8` is smaller than the size of `u32`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -238,13 +223,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:81:40
|
LL | assert::is_transmutable::< u8, u64>();
- | ^^^ `u8` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u8` is smaller than the size of `u64`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -254,13 +238,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:82:40
|
LL | assert::is_transmutable::< u8, i64>();
- | ^^^ `u8` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u8` is smaller than the size of `i64`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -270,13 +253,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:83:40
|
LL | assert::is_transmutable::< u8, f64>();
- | ^^^ `u8` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u8` is smaller than the size of `f64`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -286,13 +268,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:84:39
|
LL | assert::is_transmutable::< u8, u128>();
- | ^^^^ `u8` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `u8` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -302,13 +283,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u8` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `u8` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:85:39
|
LL | assert::is_transmutable::< u8, i128>();
- | ^^^^ `u8` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `u8` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -318,13 +298,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i16` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
+error[E0277]: `i16` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:87:40
|
LL | assert::is_transmutable::< i16, i32>();
- | ^^^ `i16` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i16` is smaller than the size of `i32`
|
- = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -334,13 +313,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i16` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
+error[E0277]: `i16` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:88:40
|
LL | assert::is_transmutable::< i16, f32>();
- | ^^^ `i16` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i16` is smaller than the size of `f32`
|
- = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -350,13 +328,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i16` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
+error[E0277]: `i16` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:89:40
|
LL | assert::is_transmutable::< i16, u32>();
- | ^^^ `i16` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i16` is smaller than the size of `u32`
|
- = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -366,13 +343,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i16` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+error[E0277]: `i16` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:90:40
|
LL | assert::is_transmutable::< i16, u64>();
- | ^^^ `i16` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i16` is smaller than the size of `u64`
|
- = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -382,13 +358,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i16` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+error[E0277]: `i16` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:91:40
|
LL | assert::is_transmutable::< i16, i64>();
- | ^^^ `i16` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i16` is smaller than the size of `i64`
|
- = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -398,13 +373,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i16` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+error[E0277]: `i16` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:92:40
|
LL | assert::is_transmutable::< i16, f64>();
- | ^^^ `i16` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i16` is smaller than the size of `f64`
|
- = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -414,13 +388,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i16` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `i16` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:93:39
|
LL | assert::is_transmutable::< i16, u128>();
- | ^^^^ `i16` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `i16` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -430,13 +403,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i16` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `i16` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:94:39
|
LL | assert::is_transmutable::< i16, i128>();
- | ^^^^ `i16` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `i16` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -446,13 +418,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u16` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
+error[E0277]: `u16` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:96:40
|
LL | assert::is_transmutable::< u16, i32>();
- | ^^^ `u16` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u16` is smaller than the size of `i32`
|
- = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -462,13 +433,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u16` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
+error[E0277]: `u16` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:97:40
|
LL | assert::is_transmutable::< u16, f32>();
- | ^^^ `u16` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u16` is smaller than the size of `f32`
|
- = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -478,13 +448,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u16` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
+error[E0277]: `u16` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:98:40
|
LL | assert::is_transmutable::< u16, u32>();
- | ^^^ `u16` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u16` is smaller than the size of `u32`
|
- = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u32`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -494,13 +463,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u16` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+error[E0277]: `u16` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:99:40
|
LL | assert::is_transmutable::< u16, u64>();
- | ^^^ `u16` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u16` is smaller than the size of `u64`
|
- = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -510,13 +478,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u16` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+error[E0277]: `u16` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:100:40
|
LL | assert::is_transmutable::< u16, i64>();
- | ^^^ `u16` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u16` is smaller than the size of `i64`
|
- = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -526,13 +493,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u16` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+error[E0277]: `u16` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:101:40
|
LL | assert::is_transmutable::< u16, f64>();
- | ^^^ `u16` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u16` is smaller than the size of `f64`
|
- = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -542,13 +508,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u16` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `u16` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:102:39
|
LL | assert::is_transmutable::< u16, u128>();
- | ^^^^ `u16` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `u16` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -558,13 +523,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u16` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `u16` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:103:39
|
LL | assert::is_transmutable::< u16, i128>();
- | ^^^^ `u16` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `u16` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -574,13 +538,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+error[E0277]: `i32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:105:40
|
LL | assert::is_transmutable::< i32, u64>();
- | ^^^ `i32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i32` is smaller than the size of `u64`
|
- = help: the trait `BikeshedIntrinsicFrom<i32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -590,13 +553,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+error[E0277]: `i32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:106:40
|
LL | assert::is_transmutable::< i32, i64>();
- | ^^^ `i32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i32` is smaller than the size of `i64`
|
- = help: the trait `BikeshedIntrinsicFrom<i32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -606,13 +568,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+error[E0277]: `i32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:107:40
|
LL | assert::is_transmutable::< i32, f64>();
- | ^^^ `i32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `i32` is smaller than the size of `f64`
|
- = help: the trait `BikeshedIntrinsicFrom<i32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -622,13 +583,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `i32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:108:39
|
LL | assert::is_transmutable::< i32, u128>();
- | ^^^^ `i32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `i32` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<i32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -638,13 +598,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `i32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:109:39
|
LL | assert::is_transmutable::< i32, i128>();
- | ^^^^ `i32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `i32` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<i32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -654,13 +613,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `f32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+error[E0277]: `f32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:111:40
|
LL | assert::is_transmutable::< f32, u64>();
- | ^^^ `f32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `f32` is smaller than the size of `u64`
|
- = help: the trait `BikeshedIntrinsicFrom<f32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -670,13 +628,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `f32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+error[E0277]: `f32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:112:40
|
LL | assert::is_transmutable::< f32, i64>();
- | ^^^ `f32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `f32` is smaller than the size of `i64`
|
- = help: the trait `BikeshedIntrinsicFrom<f32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -686,13 +643,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `f32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+error[E0277]: `f32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:113:40
|
LL | assert::is_transmutable::< f32, f64>();
- | ^^^ `f32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `f32` is smaller than the size of `f64`
|
- = help: the trait `BikeshedIntrinsicFrom<f32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -702,13 +658,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `f32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `f32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:114:39
|
LL | assert::is_transmutable::< f32, u128>();
- | ^^^^ `f32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `f32` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<f32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -718,13 +673,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `f32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `f32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:115:39
|
LL | assert::is_transmutable::< f32, i128>();
- | ^^^^ `f32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `f32` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<f32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -734,13 +688,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+error[E0277]: `u32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:117:40
|
LL | assert::is_transmutable::< u32, u64>();
- | ^^^ `u32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u32` is smaller than the size of `u64`
|
- = help: the trait `BikeshedIntrinsicFrom<u32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -750,13 +703,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+error[E0277]: `u32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:118:40
|
LL | assert::is_transmutable::< u32, i64>();
- | ^^^ `u32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u32` is smaller than the size of `i64`
|
- = help: the trait `BikeshedIntrinsicFrom<u32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -766,13 +718,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+error[E0277]: `u32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:119:40
|
LL | assert::is_transmutable::< u32, f64>();
- | ^^^ `u32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
+ | ^^^ The size of `u32` is smaller than the size of `f64`
|
- = help: the trait `BikeshedIntrinsicFrom<u32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -782,13 +733,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `u32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:120:39
|
LL | assert::is_transmutable::< u32, u128>();
- | ^^^^ `u32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `u32` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<u32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -798,13 +748,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `u32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:121:39
|
LL | assert::is_transmutable::< u32, i128>();
- | ^^^^ `u32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `u32` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<u32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -814,13 +763,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `u64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:123:39
|
LL | assert::is_transmutable::< u64, u128>();
- | ^^^^ `u64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `u64` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<u64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -830,13 +778,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `u64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `u64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:124:39
|
LL | assert::is_transmutable::< u64, i128>();
- | ^^^^ `u64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `u64` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<u64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -846,13 +793,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `i64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:126:39
|
LL | assert::is_transmutable::< i64, u128>();
- | ^^^^ `i64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `i64` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<i64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -862,13 +808,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `i64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `i64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:127:39
|
LL | assert::is_transmutable::< i64, i128>();
- | ^^^^ `i64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `i64` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<i64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -878,13 +823,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `f64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+error[E0277]: `f64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:129:39
|
LL | assert::is_transmutable::< f64, u128>();
- | ^^^^ `f64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `f64` is smaller than the size of `u128`
|
- = help: the trait `BikeshedIntrinsicFrom<f64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
@@ -894,13 +838,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-error[E0277]: `f64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+error[E0277]: `f64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`
--> $DIR/numbers.rs:130:39
|
LL | assert::is_transmutable::< f64, i128>();
- | ^^^^ `f64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
+ | ^^^^ The size of `f64` is smaller than the size of `i128`
|
- = help: the trait `BikeshedIntrinsicFrom<f64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14
|
diff --git a/tests/ui/transmutability/primitives/unit.current.stderr b/tests/ui/transmutability/primitives/unit.current.stderr
index c20355e16f5f4..c49eb6097bd0c 100644
--- a/tests/ui/transmutability/primitives/unit.current.stderr
+++ b/tests/ui/transmutability/primitives/unit.current.stderr
@@ -1,10 +1,9 @@
-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:31:35
|
LL | assert::is_transmutable::<(), u8, Context>();
- | ^^ `()` cannot be safely transmuted into `u8` in the defining scope of `should_have_correct_size::Context`.
+ | ^^ The size of `()` is smaller than the size of `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`
--> $DIR/unit.rs:15:14
|
diff --git a/tests/ui/transmutability/primitives/unit.next.stderr b/tests/ui/transmutability/primitives/unit.next.stderr
index c20355e16f5f4..c49eb6097bd0c 100644
--- a/tests/ui/transmutability/primitives/unit.next.stderr
+++ b/tests/ui/transmutability/primitives/unit.next.stderr
@@ -1,10 +1,9 @@
-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:31:35
|
LL | assert::is_transmutable::<(), u8, Context>();
- | ^^ `()` cannot be safely transmuted into `u8` in the defining scope of `should_have_correct_size::Context`.
+ | ^^ The size of `()` is smaller than the size of `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`
--> $DIR/unit.rs:15:14
|
diff --git a/tests/ui/transmutability/references.current.stderr b/tests/ui/transmutability/references.current.stderr
index 39d42cc4fa6c8..ecb095354a512 100644
--- a/tests/ui/transmutability/references.current.stderr
+++ b/tests/ui/transmutability/references.current.stderr
@@ -1,10 +1,9 @@
-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:29:52
|
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` does not have a well-specified layout
|
- = 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`
--> $DIR/references.rs:16:14
|
diff --git a/tests/ui/transmutability/references.next.stderr b/tests/ui/transmutability/references.next.stderr
index 39d42cc4fa6c8..ecb095354a512 100644
--- a/tests/ui/transmutability/references.next.stderr
+++ b/tests/ui/transmutability/references.next.stderr
@@ -1,10 +1,9 @@
-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:29:52
|
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` does not have a well-specified layout
|
- = 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`
--> $DIR/references.rs:16:14
|
diff --git a/tests/ui/transmutability/structs/repr/should_require_well_defined_layout.stderr b/tests/ui/transmutability/structs/repr/should_require_well_defined_layout.stderr
index d9aebac6417b3..4c5062cd3b303 100644
--- a/tests/ui/transmutability/structs/repr/should_require_well_defined_layout.stderr
+++ b/tests/ui/transmutability/structs/repr/should_require_well_defined_layout.stderr
@@ -1,10 +1,9 @@
-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:28:52
|
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` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
@@ -21,13 +20,12 @@ 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:29:47
|
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`.
+ | ^^^^^^^^^ `should_reject_repr_rust::unit::repr_rust` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
@@ -44,13 +42,12 @@ 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:34:52
|
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` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
@@ -67,13 +64,12 @@ 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:35:47
|
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`.
+ | ^^^^^^^^^ `should_reject_repr_rust::tuple::repr_rust` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
@@ -90,13 +86,12 @@ 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:40:52
|
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` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
@@ -113,13 +108,12 @@ 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:41:47
|
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`.
+ | ^^^^^^^^^ `should_reject_repr_rust::braces::repr_rust` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
@@ -136,13 +130,12 @@ 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:46:52
|
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` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
@@ -159,13 +152,12 @@ 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:47:47
|
LL | assert::is_maybe_transmutable::<u128, repr_rust>();
- | ^^^^^^^^^ `u128` cannot be safely transmuted into `aligned::repr_rust` in the defining scope of `assert::Context`.
+ | ^^^^^^^^^ `aligned::repr_rust` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
@@ -182,13 +174,12 @@ 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:52:52
|
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` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
@@ -205,13 +196,12 @@ 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:53:47
|
LL | assert::is_maybe_transmutable::<u128, repr_rust>();
- | ^^^^^^^^^ `u128` cannot be safely transmuted into `packed::repr_rust` in the defining scope of `assert::Context`.
+ | ^^^^^^^^^ `packed::repr_rust` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
@@ -228,13 +218,12 @@ 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:59:49
|
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` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
@@ -251,13 +240,12 @@ 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:60:47
|
LL | assert::is_maybe_transmutable::<u128, repr_c>();
- | ^^^^^^ `u128` cannot be safely transmuted into `nested::repr_c` in the defining scope of `assert::Context`.
+ | ^^^^^^ `nested::repr_c` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
diff --git a/tests/ui/transmutability/unions/repr/should_require_well_defined_layout.stderr b/tests/ui/transmutability/unions/repr/should_require_well_defined_layout.stderr
index aa0cbc51b1b22..4293d34f47b23 100644
--- a/tests/ui/transmutability/unions/repr/should_require_well_defined_layout.stderr
+++ b/tests/ui/transmutability/unions/repr/should_require_well_defined_layout.stderr
@@ -1,10 +1,9 @@
-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:30:48
|
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` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
@@ -21,13 +20,12 @@ 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:31:43
|
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`.
+ | ^^^^^^^^^ `should_reject_repr_rust::repr_rust` does not have a well-specified layout
|
- = 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`
--> $DIR/should_require_well_defined_layout.rs:13:14
|
diff --git a/tests/ui/transmutability/unions/should_pad_variants.stderr b/tests/ui/transmutability/unions/should_pad_variants.stderr
index f4988239df943..bfbef8b25fcf4 100644
--- a/tests/ui/transmutability/unions/should_pad_variants.stderr
+++ b/tests/ui/transmutability/unions/should_pad_variants.stderr
@@ -1,10 +1,9 @@
-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:44:36
|
LL | assert::is_transmutable::<Src, Dst, Context>();
- | ^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `should_pad_variants::Context`.
+ | ^^^ The size of `Src` is smaller than the size of `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`
--> $DIR/should_pad_variants.rs:13:14
|
diff --git a/tests/ui/transmutability/unions/should_reject_contraction.stderr b/tests/ui/transmutability/unions/should_reject_contraction.stderr
index fa7dcc3d22a9b..553f655a10ac0 100644
--- a/tests/ui/transmutability/unions/should_reject_contraction.stderr
+++ b/tests/ui/transmutability/unions/should_reject_contraction.stderr
@@ -1,10 +1,9 @@
-error[E0277]: `Superset` cannot be safely transmuted into `Subset` in the defining scope of `assert::Context`.
+error[E0277]: `Superset` cannot be safely transmuted into `Subset` in the defining scope of `assert::Context`
--> $DIR/should_reject_contraction.rs:35:41
|
LL | assert::is_transmutable::<Superset, Subset>();
- | ^^^^^^ `Superset` cannot be safely transmuted into `Subset` in the defining scope of `assert::Context`.
+ | ^^^^^^ At least one value of `Superset` isn't a bit-valid value of `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`
--> $DIR/should_reject_contraction.rs:13:14
|
diff --git a/tests/ui/transmutability/unions/should_reject_disjoint.stderr b/tests/ui/transmutability/unions/should_reject_disjoint.stderr
index 880e4cd89403e..178ae6f08c495 100644
--- a/tests/ui/transmutability/unions/should_reject_disjoint.stderr
+++ b/tests/ui/transmutability/unions/should_reject_disjoint.stderr
@@ -1,10 +1,9 @@
-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:33:40
|
LL | assert::is_maybe_transmutable::<A, B>();
- | ^ `A` cannot be safely transmuted into `B` in the defining scope of `assert::Context`.
+ | ^ At least one value of `A` isn't a bit-valid value of `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`
--> $DIR/should_reject_disjoint.rs:13:14
|
@@ -14,13 +13,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY.and(Assume::VALIDITY) }>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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:34:40
|
LL | assert::is_maybe_transmutable::<B, A>();
- | ^ `B` cannot be safely transmuted into `A` in the defining scope of `assert::Context`.
+ | ^ At least one value of `B` isn't a bit-valid value of `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`
--> $DIR/should_reject_disjoint.rs:13:14
|
diff --git a/tests/ui/transmutability/unions/should_reject_intersecting.stderr b/tests/ui/transmutability/unions/should_reject_intersecting.stderr
index 501760b080960..73c29ab1c970d 100644
--- a/tests/ui/transmutability/unions/should_reject_intersecting.stderr
+++ b/tests/ui/transmutability/unions/should_reject_intersecting.stderr
@@ -1,10 +1,9 @@
-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_intersecting.rs:36:34
|
LL | assert::is_transmutable::<A, B>();
- | ^ `A` cannot be safely transmuted into `B` in the defining scope of `assert::Context`.
+ | ^ At least one value of `A` isn't a bit-valid value of `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`
--> $DIR/should_reject_intersecting.rs:14:14
|
@@ -14,13 +13,12 @@ LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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
|
LL | assert::is_transmutable::<B, A>();
- | ^ `B` cannot be safely transmuted into `A` in the defining scope of `assert::Context`.
+ | ^ At least one value of `B` isn't a bit-valid value of `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`
--> $DIR/should_reject_intersecting.rs:14:14
|
diff --git a/tests/ui/transmutability/visibility/should_reject_if_dst_has_private_field.stderr b/tests/ui/transmutability/visibility/should_reject_if_dst_has_private_field.stderr
index afbba653b8345..863ada3c2c44c 100644
--- a/tests/ui/transmutability/visibility/should_reject_if_dst_has_private_field.stderr
+++ b/tests/ui/transmutability/visibility/should_reject_if_dst_has_private_field.stderr
@@ -1,10 +1,9 @@
-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:35:41
|
LL | assert::is_transmutable::<src::Src, dst::Dst, Context>();
- | ^^^^^^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`.
+ | ^^^^^^^^ `Dst` is or contains a type or field that is not visible in that scope
|
- = 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`
--> $DIR/should_reject_if_dst_has_private_field.rs:13:14
|
diff --git a/tests/ui/transmutability/visibility/should_reject_if_dst_has_private_variant.stderr b/tests/ui/transmutability/visibility/should_reject_if_dst_has_private_variant.stderr
index f14b5d8b2cb58..7b0f1b4d56ec6 100644
--- a/tests/ui/transmutability/visibility/should_reject_if_dst_has_private_variant.stderr
+++ b/tests/ui/transmutability/visibility/should_reject_if_dst_has_private_variant.stderr
@@ -1,10 +1,9 @@
-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:36:41
|
LL | assert::is_transmutable::<src::Src, dst::Dst, Context>();
- | ^^^^^^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`.
+ | ^^^^^^^^ `Dst` is or contains a type or field that is not visible in that scope
|
- = 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`
--> $DIR/should_reject_if_dst_has_private_variant.rs:13:14
|
diff --git a/tests/ui/transmutability/visibility/should_reject_if_dst_has_unreachable_field.stderr b/tests/ui/transmutability/visibility/should_reject_if_dst_has_unreachable_field.stderr
index 01ae8bea25618..df19477ef2697 100644
--- a/tests/ui/transmutability/visibility/should_reject_if_dst_has_unreachable_field.stderr
+++ b/tests/ui/transmutability/visibility/should_reject_if_dst_has_unreachable_field.stderr
@@ -1,10 +1,9 @@
-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:37:41
|
LL | assert::is_transmutable::<src::Src, dst::Dst, Context>();
- | ^^^^^^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`.
+ | ^^^^^^^^ `Dst` is or contains a type or field that is not visible in that scope
|
- = 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`
--> $DIR/should_reject_if_dst_has_unreachable_field.rs:15:14
|
diff --git a/tests/ui/transmutability/visibility/should_reject_if_dst_has_unreachable_ty.stderr b/tests/ui/transmutability/visibility/should_reject_if_dst_has_unreachable_ty.stderr
index 20a680a748456..ea488980cdd14 100644
--- a/tests/ui/transmutability/visibility/should_reject_if_dst_has_unreachable_ty.stderr
+++ b/tests/ui/transmutability/visibility/should_reject_if_dst_has_unreachable_ty.stderr
@@ -10,13 +10,12 @@ note: the struct `Dst` is defined here
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:38:41
|
LL | assert::is_transmutable::<src::Src, dst::Dst, Context>();
- | ^^^^^^^^ `Src` cannot be safely transmuted into `Dst` in the defining scope of `test::Context`.
+ | ^^^^^^^^ `Dst` is or contains a type or field that is not visible in that scope
|
- = 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`
--> $DIR/should_reject_if_dst_has_unreachable_ty.rs:15:14
|
diff --git a/tests/ui/transmute/transmute-padding-ice.stderr b/tests/ui/transmute/transmute-padding-ice.stderr
index 87fd4fb663086..f5480e0b9fb82 100644
--- a/tests/ui/transmute/transmute-padding-ice.stderr
+++ b/tests/ui/transmute/transmute-padding-ice.stderr
@@ -1,10 +1,9 @@
-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/transmute-padding-ice.rs:27:40
|
LL | assert::is_maybe_transmutable::<B, A>();
- | ^ `B` cannot be safely transmuted into `A` in the defining scope of `assert::Context`.
+ | ^ The size of `B` is smaller than the size of `A`
|
- = help: the trait `BikeshedIntrinsicFrom<B, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `A`
note: required by a bound in `is_maybe_transmutable`
--> $DIR/transmute-padding-ice.rs:11:14
|