[rustc.git] / src / test / ui / transmutability / structs / repr / should_require_well_defined_layout.stderr

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`.
   |
   = 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
   |
LL |       pub fn is_maybe_transmutable<Src, Dst>()
   |              --------------------- required by a bound in this
LL |       where
LL |           Dst: BikeshedIntrinsicFrom<Src, Context, {
   |  ______________^
LL | |             Assume {
LL | |                 alignment: true,
LL | |                 lifetimes: true,
...  |
LL | |             }
LL | |         }>
   | |__________^ required by this bound in `is_maybe_transmutable`

error[E0277]: `u128` cannot be safely transmuted into `should_reject_repr_rust::unit::repr_rust` in the defining scope of `assert::Context`.
  --> $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`.
   |
   = 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
   |
LL |       pub fn is_maybe_transmutable<Src, Dst>()
   |              --------------------- required by a bound in this
LL |       where
LL |           Dst: BikeshedIntrinsicFrom<Src, Context, {
   |  ______________^
LL | |             Assume {
LL | |                 alignment: true,
LL | |                 lifetimes: true,
...  |
LL | |             }
LL | |         }>
   | |__________^ required by this bound in `is_maybe_transmutable`

error[E0277]: `should_reject_repr_rust::tuple::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
  --> $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`.
   |
   = 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
   |
LL |       pub fn is_maybe_transmutable<Src, Dst>()
   |              --------------------- required by a bound in this
LL |       where
LL |           Dst: BikeshedIntrinsicFrom<Src, Context, {
   |  ______________^
LL | |             Assume {
LL | |                 alignment: true,
LL | |                 lifetimes: true,
...  |
LL | |             }
LL | |         }>
   | |__________^ required by this bound in `is_maybe_transmutable`

error[E0277]: `u128` cannot be safely transmuted into `should_reject_repr_rust::tuple::repr_rust` in the defining scope of `assert::Context`.
  --> $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`.
   |
   = 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
   |
LL |       pub fn is_maybe_transmutable<Src, Dst>()
   |              --------------------- required by a bound in this
LL |       where
LL |           Dst: BikeshedIntrinsicFrom<Src, Context, {
   |  ______________^
LL | |             Assume {
LL | |                 alignment: true,
LL | |                 lifetimes: true,
...  |
LL | |             }
LL | |         }>
   | |__________^ required by this bound in `is_maybe_transmutable`

error[E0277]: `should_reject_repr_rust::braces::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
  --> $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`.
   |
   = 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
   |
LL |       pub fn is_maybe_transmutable<Src, Dst>()
   |              --------------------- required by a bound in this
LL |       where
LL |           Dst: BikeshedIntrinsicFrom<Src, Context, {
   |  ______________^
LL | |             Assume {
LL | |                 alignment: true,
LL | |                 lifetimes: true,
...  |
LL | |             }
LL | |         }>
   | |__________^ required by this bound in `is_maybe_transmutable`

error[E0277]: `u128` cannot be safely transmuted into `should_reject_repr_rust::braces::repr_rust` in the defining scope of `assert::Context`.
  --> $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`.
   |
   = 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
   |
LL |       pub fn is_maybe_transmutable<Src, Dst>()
   |              --------------------- required by a bound in this
LL |       where
LL |           Dst: BikeshedIntrinsicFrom<Src, Context, {
   |  ______________^
LL | |             Assume {
LL | |                 alignment: true,
LL | |                 lifetimes: true,
...  |
LL | |             }
LL | |         }>
   | |__________^ required by this bound in `is_maybe_transmutable`

error[E0277]: `aligned::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
  --> $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`.
   |
   = 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
   |
LL |       pub fn is_maybe_transmutable<Src, Dst>()
   |              --------------------- required by a bound in this
LL |       where
LL |           Dst: BikeshedIntrinsicFrom<Src, Context, {
   |  ______________^
LL | |             Assume {
LL | |                 alignment: true,
LL | |                 lifetimes: true,
...  |
LL | |             }
LL | |         }>
   | |__________^ required by this bound in `is_maybe_transmutable`

error[E0277]: `u128` cannot be safely transmuted into `aligned::repr_rust` in the defining scope of `assert::Context`.
  --> $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`.
   |
   = 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
   |
LL |       pub fn is_maybe_transmutable<Src, Dst>()
   |              --------------------- required by a bound in this
LL |       where
LL |           Dst: BikeshedIntrinsicFrom<Src, Context, {
   |  ______________^
LL | |             Assume {
LL | |                 alignment: true,
LL | |                 lifetimes: true,
...  |
LL | |             }
LL | |         }>
   | |__________^ required by this bound in `is_maybe_transmutable`

error[E0277]: `packed::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
  --> $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`.
   |
   = 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
   |
LL |       pub fn is_maybe_transmutable<Src, Dst>()
   |              --------------------- required by a bound in this
LL |       where
LL |           Dst: BikeshedIntrinsicFrom<Src, Context, {
   |  ______________^
LL | |             Assume {
LL | |                 alignment: true,
LL | |                 lifetimes: true,
...  |
LL | |             }
LL | |         }>
   | |__________^ required by this bound in `is_maybe_transmutable`

error[E0277]: `u128` cannot be safely transmuted into `packed::repr_rust` in the defining scope of `assert::Context`.
  --> $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`.
   |
   = 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
   |
LL |       pub fn is_maybe_transmutable<Src, Dst>()
   |              --------------------- required by a bound in this
LL |       where
LL |           Dst: BikeshedIntrinsicFrom<Src, Context, {
   |  ______________^
LL | |             Assume {
LL | |                 alignment: true,
LL | |                 lifetimes: true,
...  |
LL | |             }
LL | |         }>
   | |__________^ required by this bound in `is_maybe_transmutable`

error[E0277]: `nested::repr_c` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
  --> $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`.
   |
   = 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
   |
LL |       pub fn is_maybe_transmutable<Src, Dst>()
   |              --------------------- required by a bound in this
LL |       where
LL |           Dst: BikeshedIntrinsicFrom<Src, Context, {
   |  ______________^
LL | |             Assume {
LL | |                 alignment: true,
LL | |                 lifetimes: true,
...  |
LL | |             }
LL | |         }>
   | |__________^ required by this bound in `is_maybe_transmutable`

error[E0277]: `u128` cannot be safely transmuted into `nested::repr_c` in the defining scope of `assert::Context`.
  --> $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`.
   |
   = 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
   |
LL |       pub fn is_maybe_transmutable<Src, Dst>()
   |              --------------------- required by a bound in this
LL |       where
LL |           Dst: BikeshedIntrinsicFrom<Src, Context, {
   |  ______________^
LL | |             Assume {
LL | |                 alignment: true,
LL | |                 lifetimes: true,
...  |
LL | |             }
LL | |         }>
   | |__________^ required by this bound in `is_maybe_transmutable`

error: aborting due to 12 previous errors

For more information about this error, try `rustc --explain E0277`.
Commit	Line	Data
064997fb	1	error[E0277]: `should_reject_repr_rust::unit::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
f2b60f7d	2	--> $DIR/should_require_well_defined_layout.rs:28:52
064997fb FG	3	\|
	4	LL \| assert::is_maybe_transmutable::<repr_rust, ()>();
	5	\| ^^ `should_reject_repr_rust::unit::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
	6	\|
f2b60f7d	7	= 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 `()`
064997fb FG	8	note: required by a bound in `is_maybe_transmutable`
	9	--> $DIR/should_require_well_defined_layout.rs:13:14
	10	\|
f2b60f7d FG	11	LL \| pub fn is_maybe_transmutable<Src, Dst>()
	12	\| --------------------- required by a bound in this
	13	LL \| where
	14	LL \| Dst: BikeshedIntrinsicFrom<Src, Context, {
	15	\| ______________^
	16	LL \| \| Assume {
	17	LL \| \| alignment: true,
	18	LL \| \| lifetimes: true,
	19	... \|
	20	LL \| \| }
	21	LL \| \| }>
	22	\| \|__________^ required by this bound in `is_maybe_transmutable`
064997fb FG	23
064997fb FG	24	error[E0277]: `u128` cannot be safely transmuted into `should_reject_repr_rust::unit::repr_rust` in the defining scope of `assert::Context`.
f2b60f7d	25	--> $DIR/should_require_well_defined_layout.rs:29:47
064997fb FG	26	\|
	27	LL \| assert::is_maybe_transmutable::<u128, repr_rust>();
	28	\| ^^^^^^^^^ `u128` cannot be safely transmuted into `should_reject_repr_rust::unit::repr_rust` in the defining scope of `assert::Context`.
	29	\|
f2b60f7d	30	= 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`
064997fb FG	31	note: required by a bound in `is_maybe_transmutable`
	32	--> $DIR/should_require_well_defined_layout.rs:13:14
	33	\|
f2b60f7d FG	34	LL \| pub fn is_maybe_transmutable<Src, Dst>()
	35	\| --------------------- required by a bound in this
	36	LL \| where
	37	LL \| Dst: BikeshedIntrinsicFrom<Src, Context, {
	38	\| ______________^
	39	LL \| \| Assume {
	40	LL \| \| alignment: true,
	41	LL \| \| lifetimes: true,
	42	... \|
	43	LL \| \| }
	44	LL \| \| }>
	45	\| \|__________^ required by this bound in `is_maybe_transmutable`
064997fb FG	46
064997fb FG	47	error[E0277]: `should_reject_repr_rust::tuple::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
f2b60f7d	48	--> $DIR/should_require_well_defined_layout.rs:34:52
064997fb FG	49	\|
	50	LL \| assert::is_maybe_transmutable::<repr_rust, ()>();
	51	\| ^^ `should_reject_repr_rust::tuple::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
	52	\|
f2b60f7d	53	= 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 `()`
064997fb FG	54	note: required by a bound in `is_maybe_transmutable`
	55	--> $DIR/should_require_well_defined_layout.rs:13:14
	56	\|
f2b60f7d FG	57	LL \| pub fn is_maybe_transmutable<Src, Dst>()
	58	\| --------------------- required by a bound in this
	59	LL \| where
	60	LL \| Dst: BikeshedIntrinsicFrom<Src, Context, {
	61	\| ______________^
	62	LL \| \| Assume {
	63	LL \| \| alignment: true,
	64	LL \| \| lifetimes: true,
	65	... \|
	66	LL \| \| }
	67	LL \| \| }>
	68	\| \|__________^ required by this bound in `is_maybe_transmutable`
064997fb FG	69
064997fb FG	70	error[E0277]: `u128` cannot be safely transmuted into `should_reject_repr_rust::tuple::repr_rust` in the defining scope of `assert::Context`.
f2b60f7d	71	--> $DIR/should_require_well_defined_layout.rs:35:47
064997fb FG	72	\|
	73	LL \| assert::is_maybe_transmutable::<u128, repr_rust>();
	74	\| ^^^^^^^^^ `u128` cannot be safely transmuted into `should_reject_repr_rust::tuple::repr_rust` in the defining scope of `assert::Context`.
	75	\|
f2b60f7d	76	= 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`
064997fb FG	77	note: required by a bound in `is_maybe_transmutable`
	78	--> $DIR/should_require_well_defined_layout.rs:13:14
	79	\|
f2b60f7d FG	80	LL \| pub fn is_maybe_transmutable<Src, Dst>()
	81	\| --------------------- required by a bound in this
	82	LL \| where
	83	LL \| Dst: BikeshedIntrinsicFrom<Src, Context, {
	84	\| ______________^
	85	LL \| \| Assume {
	86	LL \| \| alignment: true,
	87	LL \| \| lifetimes: true,
	88	... \|
	89	LL \| \| }
	90	LL \| \| }>
	91	\| \|__________^ required by this bound in `is_maybe_transmutable`
064997fb FG	92
064997fb FG	93	error[E0277]: `should_reject_repr_rust::braces::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
f2b60f7d	94	--> $DIR/should_require_well_defined_layout.rs:40:52
064997fb FG	95	\|
	96	LL \| assert::is_maybe_transmutable::<repr_rust, ()>();
	97	\| ^^ `should_reject_repr_rust::braces::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
	98	\|
f2b60f7d	99	= 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 `()`
064997fb FG	100	note: required by a bound in `is_maybe_transmutable`
	101	--> $DIR/should_require_well_defined_layout.rs:13:14
	102	\|
f2b60f7d FG	103	LL \| pub fn is_maybe_transmutable<Src, Dst>()
	104	\| --------------------- required by a bound in this
	105	LL \| where
	106	LL \| Dst: BikeshedIntrinsicFrom<Src, Context, {
	107	\| ______________^
	108	LL \| \| Assume {
	109	LL \| \| alignment: true,
	110	LL \| \| lifetimes: true,
	111	... \|
	112	LL \| \| }
	113	LL \| \| }>
	114	\| \|__________^ required by this bound in `is_maybe_transmutable`
064997fb FG	115
064997fb FG	116	error[E0277]: `u128` cannot be safely transmuted into `should_reject_repr_rust::braces::repr_rust` in the defining scope of `assert::Context`.
f2b60f7d	117	--> $DIR/should_require_well_defined_layout.rs:41:47
064997fb FG	118	\|
	119	LL \| assert::is_maybe_transmutable::<u128, repr_rust>();
	120	\| ^^^^^^^^^ `u128` cannot be safely transmuted into `should_reject_repr_rust::braces::repr_rust` in the defining scope of `assert::Context`.
	121	\|
f2b60f7d	122	= 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`
064997fb FG	123	note: required by a bound in `is_maybe_transmutable`
	124	--> $DIR/should_require_well_defined_layout.rs:13:14
	125	\|
f2b60f7d FG	126	LL \| pub fn is_maybe_transmutable<Src, Dst>()
	127	\| --------------------- required by a bound in this
	128	LL \| where
	129	LL \| Dst: BikeshedIntrinsicFrom<Src, Context, {
	130	\| ______________^
	131	LL \| \| Assume {
	132	LL \| \| alignment: true,
	133	LL \| \| lifetimes: true,
	134	... \|
	135	LL \| \| }
	136	LL \| \| }>
	137	\| \|__________^ required by this bound in `is_maybe_transmutable`
064997fb FG	138
064997fb FG	139	error[E0277]: `aligned::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
f2b60f7d	140	--> $DIR/should_require_well_defined_layout.rs:46:52
064997fb FG	141	\|
	142	LL \| assert::is_maybe_transmutable::<repr_rust, ()>();
	143	\| ^^ `aligned::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
	144	\|
f2b60f7d	145	= help: the trait `BikeshedIntrinsicFrom<aligned::repr_rust, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `()`
064997fb FG	146	note: required by a bound in `is_maybe_transmutable`
	147	--> $DIR/should_require_well_defined_layout.rs:13:14
	148	\|
f2b60f7d FG	149	LL \| pub fn is_maybe_transmutable<Src, Dst>()
	150	\| --------------------- required by a bound in this
	151	LL \| where
	152	LL \| Dst: BikeshedIntrinsicFrom<Src, Context, {
	153	\| ______________^
	154	LL \| \| Assume {
	155	LL \| \| alignment: true,
	156	LL \| \| lifetimes: true,
	157	... \|
	158	LL \| \| }
	159	LL \| \| }>
	160	\| \|__________^ required by this bound in `is_maybe_transmutable`
064997fb FG	161
064997fb FG	162	error[E0277]: `u128` cannot be safely transmuted into `aligned::repr_rust` in the defining scope of `assert::Context`.
f2b60f7d	163	--> $DIR/should_require_well_defined_layout.rs:47:47
064997fb FG	164	\|
	165	LL \| assert::is_maybe_transmutable::<u128, repr_rust>();
	166	\| ^^^^^^^^^ `u128` cannot be safely transmuted into `aligned::repr_rust` in the defining scope of `assert::Context`.
	167	\|
f2b60f7d	168	= help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `aligned::repr_rust`
064997fb FG	169	note: required by a bound in `is_maybe_transmutable`
	170	--> $DIR/should_require_well_defined_layout.rs:13:14
	171	\|
f2b60f7d FG	172	LL \| pub fn is_maybe_transmutable<Src, Dst>()
	173	\| --------------------- required by a bound in this
	174	LL \| where
	175	LL \| Dst: BikeshedIntrinsicFrom<Src, Context, {
	176	\| ______________^
	177	LL \| \| Assume {
	178	LL \| \| alignment: true,
	179	LL \| \| lifetimes: true,
	180	... \|
	181	LL \| \| }
	182	LL \| \| }>
	183	\| \|__________^ required by this bound in `is_maybe_transmutable`
064997fb FG	184
064997fb FG	185	error[E0277]: `packed::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
f2b60f7d	186	--> $DIR/should_require_well_defined_layout.rs:52:52
064997fb FG	187	\|
	188	LL \| assert::is_maybe_transmutable::<repr_rust, ()>();
	189	\| ^^ `packed::repr_rust` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
	190	\|
f2b60f7d	191	= help: the trait `BikeshedIntrinsicFrom<packed::repr_rust, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `()`
064997fb FG	192	note: required by a bound in `is_maybe_transmutable`
	193	--> $DIR/should_require_well_defined_layout.rs:13:14
	194	\|
f2b60f7d FG	195	LL \| pub fn is_maybe_transmutable<Src, Dst>()
	196	\| --------------------- required by a bound in this
	197	LL \| where
	198	LL \| Dst: BikeshedIntrinsicFrom<Src, Context, {
	199	\| ______________^
	200	LL \| \| Assume {
	201	LL \| \| alignment: true,
	202	LL \| \| lifetimes: true,
	203	... \|
	204	LL \| \| }
	205	LL \| \| }>
	206	\| \|__________^ required by this bound in `is_maybe_transmutable`
064997fb FG	207
064997fb FG	208	error[E0277]: `u128` cannot be safely transmuted into `packed::repr_rust` in the defining scope of `assert::Context`.
f2b60f7d	209	--> $DIR/should_require_well_defined_layout.rs:53:47
064997fb FG	210	\|
	211	LL \| assert::is_maybe_transmutable::<u128, repr_rust>();
	212	\| ^^^^^^^^^ `u128` cannot be safely transmuted into `packed::repr_rust` in the defining scope of `assert::Context`.
	213	\|
f2b60f7d	214	= help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `packed::repr_rust`
064997fb FG	215	note: required by a bound in `is_maybe_transmutable`
	216	--> $DIR/should_require_well_defined_layout.rs:13:14
	217	\|
f2b60f7d FG	218	LL \| pub fn is_maybe_transmutable<Src, Dst>()
	219	\| --------------------- required by a bound in this
	220	LL \| where
	221	LL \| Dst: BikeshedIntrinsicFrom<Src, Context, {
	222	\| ______________^
	223	LL \| \| Assume {
	224	LL \| \| alignment: true,
	225	LL \| \| lifetimes: true,
	226	... \|
	227	LL \| \| }
	228	LL \| \| }>
	229	\| \|__________^ required by this bound in `is_maybe_transmutable`
064997fb FG	230
064997fb FG	231	error[E0277]: `nested::repr_c` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
f2b60f7d	232	--> $DIR/should_require_well_defined_layout.rs:59:49
064997fb FG	233	\|
	234	LL \| assert::is_maybe_transmutable::<repr_c, ()>();
	235	\| ^^ `nested::repr_c` cannot be safely transmuted into `()` in the defining scope of `assert::Context`.
	236	\|
f2b60f7d	237	= help: the trait `BikeshedIntrinsicFrom<nested::repr_c, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `()`
064997fb FG	238	note: required by a bound in `is_maybe_transmutable`
	239	--> $DIR/should_require_well_defined_layout.rs:13:14
	240	\|
f2b60f7d FG	241	LL \| pub fn is_maybe_transmutable<Src, Dst>()
	242	\| --------------------- required by a bound in this
	243	LL \| where
	244	LL \| Dst: BikeshedIntrinsicFrom<Src, Context, {
	245	\| ______________^
	246	LL \| \| Assume {
	247	LL \| \| alignment: true,
	248	LL \| \| lifetimes: true,
	249	... \|
	250	LL \| \| }
	251	LL \| \| }>
	252	\| \|__________^ required by this bound in `is_maybe_transmutable`
064997fb FG	253
064997fb FG	254	error[E0277]: `u128` cannot be safely transmuted into `nested::repr_c` in the defining scope of `assert::Context`.
f2b60f7d	255	--> $DIR/should_require_well_defined_layout.rs:60:47
064997fb FG	256	\|
	257	LL \| assert::is_maybe_transmutable::<u128, repr_c>();
	258	\| ^^^^^^ `u128` cannot be safely transmuted into `nested::repr_c` in the defining scope of `assert::Context`.
	259	\|
f2b60f7d	260	= help: the trait `BikeshedIntrinsicFrom<u128, assert::Context, Assume { alignment: true, lifetimes: true, safety: true, validity: true }>` is not implemented for `nested::repr_c`
064997fb FG	261	note: required by a bound in `is_maybe_transmutable`
	262	--> $DIR/should_require_well_defined_layout.rs:13:14
	263	\|
f2b60f7d FG	264	LL \| pub fn is_maybe_transmutable<Src, Dst>()
	265	\| --------------------- required by a bound in this
	266	LL \| where
	267	LL \| Dst: BikeshedIntrinsicFrom<Src, Context, {
	268	\| ______________^
	269	LL \| \| Assume {
	270	LL \| \| alignment: true,
	271	LL \| \| lifetimes: true,
	272	... \|
	273	LL \| \| }
	274	LL \| \| }>
	275	\| \|__________^ required by this bound in `is_maybe_transmutable`
064997fb FG	276
	277	error: aborting due to 12 previous errors
	278
	279	For more information about this error, try `rustc --explain E0277`.