Safe Transmute: Fix propagation of errors

bryangarza · bryangarza · commit 94ad084ac611 · 2023-05-24T14:52:19.000-07:00
- Make sure that the most specific Reason is the one that bubbles up when we
  are folding over the `Answer` tree. `Reason::DstIsBitIncompatible` is the
  least specific, so that should be used only when there isn't anything else
  available.
- Small fixes where we used the wrong Reason variant.
- Tiny cleanups
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
@@ -2751,7 +2751,8 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
             rustc_transmute::Assume::from_const(self.infcx.tcx, obligation.param_env, trait_ref.substs.const_at(3)) else {
                 span_bug!(span, "Unable to construct rustc_transmute::Assume where it was previously possible");
             };
-        // FIXME(bryangarza): Need to flatten here too
+        // FIXME(bryangarza): Is this enough, or should we resolve all nested
+        // obligations like we do for `confirm_transmutability_candidate(...)?`
         match rustc_transmute::TransmuteTypeEnv::new(self.infcx).is_transmutable(
             obligation.cause,
             src_and_dst,
@@ -2780,7 +2781,6 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
                     rustc_transmute::Reason::DstIsPrivate => format!(
                         "`{dst}` is or contains a type or field that is not visible in that scope"
                     ),
-                    // 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}`")
                     }
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -329,7 +329,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                         )
                     };
 
-                    // // FIXME(bryangarza): Check src.mutability or dst.mutability to know whether dst -> src obligation is needed
+                    // FIXME(bryangarza): Check src.mutability or dst.mutability to know whether dst -> src obligation is needed
                     Ok(vec![make_obl(src.ty, dst.ty), make_obl(dst.ty, src.ty)])
                 }
             }
diff --git a/compiler/rustc_transmute/src/lib.rs b/compiler/rustc_transmute/src/lib.rs
@@ -1,4 +1,4 @@
-#![feature(alloc_layout_extra, decl_macro, iterator_try_reduce, never_type)]
+#![feature(alloc_layout_extra, decl_macro, iterator_try_reduce, never_type, let_chains)]
 #![allow(dead_code, unused_variables)]
 #![deny(rustc::untranslatable_diagnostic)]
 #![deny(rustc::diagnostic_outside_of_impl)]
diff --git a/compiler/rustc_transmute/src/maybe_transmutable/mod.rs b/compiler/rustc_transmute/src/maybe_transmutable/mod.rs
@@ -78,11 +78,12 @@ mod rustc {
                 match (src, dst) {
                     // Answer `Ok(None)` 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(Err::TypeError(_))) => Err(Ok(None)),
-                    (Err(Err::Unknown), _) | (_, Err(Err::Unknown)) => Err(Ok(None)),
-                    (Err(Err::Unspecified), _) | (_, Err(Err::Unspecified)) => {
-                        Err(Err(Reason::SrcIsUnspecified))
-                    }
+                    (Err(Err::TypeError(_)), _)
+                    | (_, Err(Err::TypeError(_)))
+                    | (Err(Err::Unknown), _)
+                    | (_, Err(Err::Unknown)) => Err(Ok(None)),
+                    (Err(Err::Unspecified), _) => Err(Err(Reason::SrcIsUnspecified)),
+                    (_, Err(Err::Unspecified)) => Err(Err(Reason::DstIsUnspecified)),
                     (Ok(src), Ok(dst)) => Ok((src, dst)),
                 }
             });
@@ -316,12 +317,19 @@ where
     }
 }
 
-fn and<R>(lhs: Answer<R>, rhs: Answer<R>) -> Answer<R> {
-    // Should propagate errors on the right side, because the initial value
-    // used in `apply` is on the left side.
-    let rhs = rhs?;
-    let lhs = lhs?;
-    Ok(match (lhs, rhs) {
+fn and<R>(lhs: Answer<R>, rhs: Answer<R>) -> Answer<R>
+where
+    R: PartialEq,
+{
+    // If both are errors, then we should return the more specific one
+    if lhs.is_err() && rhs.is_err() {
+        if lhs == Err(Reason::DstIsBitIncompatible) {
+            return rhs;
+        } else {
+            return lhs;
+        }
+    }
+    Ok(match (lhs?, rhs?) {
         // If only one side has a condition, pass it along
         (None, other) | (other, None) => other,
         // If both sides have IfAll conditions, merge them
@@ -340,10 +348,17 @@ fn and<R>(lhs: Answer<R>, rhs: Answer<R>) -> Answer<R> {
     })
 }
 
-fn or<R>(lhs: Answer<R>, rhs: Answer<R>) -> Answer<R> {
-    // If both are errors, then we should return the one on the right
+fn or<R>(lhs: Answer<R>, rhs: Answer<R>) -> Answer<R>
+where
+    R: PartialEq,
+{
+    // If both are errors, then we should return the more specific one
     if lhs.is_err() && rhs.is_err() {
-        return rhs;
+        if lhs == Err(Reason::DstIsBitIncompatible) {
+            return rhs;
+        } else {
+            return lhs;
+        }
     }
     // Otherwise, errors can be ignored for the rest of the pattern matching
     let lhs = lhs.unwrap_or(None);
diff --git a/tests/ui/transmutability/arrays/should_require_well_defined_layout.stderr b/tests/ui/transmutability/arrays/should_require_well_defined_layout.stderr
@@ -23,7 +23,7 @@ error[E0277]: `u128` cannot be safely transmuted into `[String; 0]` in the defin
   --> $DIR/should_require_well_defined_layout.rs:27:47
    |
 LL |         assert::is_maybe_transmutable::<u128, repr_rust>();
-   |                                               ^^^^^^^^^ `u128` does not have a well-specified layout
+   |                                               ^^^^^^^^^ `[String; 0]` does not have a well-specified layout
    |
 note: required by a bound in `is_maybe_transmutable`
   --> $DIR/should_require_well_defined_layout.rs:13:14
@@ -65,7 +65,7 @@ error[E0277]: `u128` cannot be safely transmuted into `[String; 1]` in the defin
   --> $DIR/should_require_well_defined_layout.rs:33:47
    |
 LL |         assert::is_maybe_transmutable::<u128, repr_rust>();
-   |                                               ^^^^^^^^^ `u128` does not have a well-specified layout
+   |                                               ^^^^^^^^^ `[String; 1]` does not have a well-specified layout
    |
 note: required by a bound in `is_maybe_transmutable`
   --> $DIR/should_require_well_defined_layout.rs:13:14
@@ -107,7 +107,7 @@ error[E0277]: `u128` cannot be safely transmuted into `[String; 2]` in the defin
   --> $DIR/should_require_well_defined_layout.rs:39:47
    |
 LL |         assert::is_maybe_transmutable::<u128, repr_rust>();
-   |                                               ^^^^^^^^^ `u128` does not have a well-specified layout
+   |                                               ^^^^^^^^^ `[String; 2]` does not have a well-specified layout
    |
 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
@@ -24,7 +24,7 @@ error[E0277]: `V0i8` cannot be safely transmuted into `u16` in the defining scop
   --> $DIR/primitive_reprs_should_have_correct_length.rs:50:44
    |
 LL |         assert::is_transmutable::<Current, Larger, Context>();
-   |                                            ^^^^^^ At least one value of `V0i8` isn't a bit-valid value of `u16`
+   |                                            ^^^^^^ The size of `V0i8` is smaller than the size of `u16`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
@@ -68,7 +68,7 @@ error[E0277]: `V0u8` cannot be safely transmuted into `u16` in the defining scop
   --> $DIR/primitive_reprs_should_have_correct_length.rs:58:44
    |
 LL |         assert::is_transmutable::<Current, Larger, Context>();
-   |                                            ^^^^^^ At least one value of `V0u8` isn't a bit-valid value of `u16`
+   |                                            ^^^^^^ The size of `V0u8` is smaller than the size of `u16`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
@@ -90,7 +90,7 @@ error[E0277]: `u8` cannot be safely transmuted into `V0i16` in the defining scop
   --> $DIR/primitive_reprs_should_have_correct_length.rs:72:44
    |
 LL |         assert::is_transmutable::<Smaller, Current, Context>();
-   |                                            ^^^^^^^ At least one value of `u8` isn't a bit-valid value of `V0i16`
+   |                                            ^^^^^^^ The size of `u8` is smaller than the size of `V0i16`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
@@ -112,7 +112,7 @@ error[E0277]: `V0i16` cannot be safely transmuted into `u32` in the defining sco
   --> $DIR/primitive_reprs_should_have_correct_length.rs:74:44
    |
 LL |         assert::is_transmutable::<Current, Larger, Context>();
-   |                                            ^^^^^^ At least one value of `V0i16` isn't a bit-valid value of `u32`
+   |                                            ^^^^^^ The size of `V0i16` is smaller than the size of `u32`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
@@ -134,7 +134,7 @@ error[E0277]: `u8` cannot be safely transmuted into `V0u16` in the defining scop
   --> $DIR/primitive_reprs_should_have_correct_length.rs:80:44
    |
 LL |         assert::is_transmutable::<Smaller, Current, Context>();
-   |                                            ^^^^^^^ At least one value of `u8` isn't a bit-valid value of `V0u16`
+   |                                            ^^^^^^^ The size of `u8` is smaller than the size of `V0u16`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
@@ -156,7 +156,7 @@ error[E0277]: `V0u16` cannot be safely transmuted into `u32` in the defining sco
   --> $DIR/primitive_reprs_should_have_correct_length.rs:82:44
    |
 LL |         assert::is_transmutable::<Current, Larger, Context>();
-   |                                            ^^^^^^ At least one value of `V0u16` isn't a bit-valid value of `u32`
+   |                                            ^^^^^^ The size of `V0u16` is smaller than the size of `u32`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
@@ -178,7 +178,7 @@ error[E0277]: `u16` cannot be safely transmuted into `V0i32` in the defining sco
   --> $DIR/primitive_reprs_should_have_correct_length.rs:96:44
    |
 LL |         assert::is_transmutable::<Smaller, Current, Context>();
-   |                                            ^^^^^^^ At least one value of `u16` isn't a bit-valid value of `V0i32`
+   |                                            ^^^^^^^ The size of `u16` is smaller than the size of `V0i32`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
@@ -200,7 +200,7 @@ error[E0277]: `V0i32` cannot be safely transmuted into `u64` in the defining sco
   --> $DIR/primitive_reprs_should_have_correct_length.rs:98:44
    |
 LL |         assert::is_transmutable::<Current, Larger, Context>();
-   |                                            ^^^^^^ At least one value of `V0i32` isn't a bit-valid value of `u64`
+   |                                            ^^^^^^ The size of `V0i32` is smaller than the size of `u64`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
@@ -222,7 +222,7 @@ error[E0277]: `u16` cannot be safely transmuted into `V0u32` in the defining sco
   --> $DIR/primitive_reprs_should_have_correct_length.rs:104:44
    |
 LL |         assert::is_transmutable::<Smaller, Current, Context>();
-   |                                            ^^^^^^^ At least one value of `u16` isn't a bit-valid value of `V0u32`
+   |                                            ^^^^^^^ The size of `u16` is smaller than the size of `V0u32`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
@@ -244,7 +244,7 @@ error[E0277]: `V0u32` cannot be safely transmuted into `u64` in the defining sco
   --> $DIR/primitive_reprs_should_have_correct_length.rs:106:44
    |
 LL |         assert::is_transmutable::<Current, Larger, Context>();
-   |                                            ^^^^^^ At least one value of `V0u32` isn't a bit-valid value of `u64`
+   |                                            ^^^^^^ The size of `V0u32` is smaller than the size of `u64`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
@@ -266,7 +266,7 @@ error[E0277]: `u32` cannot be safely transmuted into `V0i64` in the defining sco
   --> $DIR/primitive_reprs_should_have_correct_length.rs:120:44
    |
 LL |         assert::is_transmutable::<Smaller, Current, Context>();
-   |                                            ^^^^^^^ At least one value of `u32` isn't a bit-valid value of `V0i64`
+   |                                            ^^^^^^^ The size of `u32` is smaller than the size of `V0i64`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
@@ -288,7 +288,7 @@ error[E0277]: `V0i64` cannot be safely transmuted into `u128` in the defining sc
   --> $DIR/primitive_reprs_should_have_correct_length.rs:122:44
    |
 LL |         assert::is_transmutable::<Current, Larger, Context>();
-   |                                            ^^^^^^ At least one value of `V0i64` isn't a bit-valid value of `u128`
+   |                                            ^^^^^^ The size of `V0i64` is smaller than the size of `u128`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
@@ -310,7 +310,7 @@ error[E0277]: `u32` cannot be safely transmuted into `V0u64` in the defining sco
   --> $DIR/primitive_reprs_should_have_correct_length.rs:128:44
    |
 LL |         assert::is_transmutable::<Smaller, Current, Context>();
-   |                                            ^^^^^^^ At least one value of `u32` isn't a bit-valid value of `V0u64`
+   |                                            ^^^^^^^ The size of `u32` is smaller than the size of `V0u64`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
@@ -332,7 +332,7 @@ error[E0277]: `V0u64` cannot be safely transmuted into `u128` in the defining sc
   --> $DIR/primitive_reprs_should_have_correct_length.rs:130:44
    |
 LL |         assert::is_transmutable::<Current, Larger, Context>();
-   |                                            ^^^^^^ At least one value of `V0u64` isn't a bit-valid value of `u128`
+   |                                            ^^^^^^ The size of `V0u64` is smaller than the size of `u128`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
@@ -354,7 +354,7 @@ error[E0277]: `u8` cannot be safely transmuted into `V0isize` in the defining sc
   --> $DIR/primitive_reprs_should_have_correct_length.rs:144:44
    |
 LL |         assert::is_transmutable::<Smaller, Current, Context>();
-   |                                            ^^^^^^^ At least one value of `u8` isn't a bit-valid value of `V0isize`
+   |                                            ^^^^^^^ The size of `u8` is smaller than the size of `V0isize`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
@@ -376,7 +376,7 @@ error[E0277]: `V0isize` cannot be safely transmuted into `[usize; 2]` in the def
   --> $DIR/primitive_reprs_should_have_correct_length.rs:146:44
    |
 LL |         assert::is_transmutable::<Current, Larger, Context>();
-   |                                            ^^^^^^ At least one value of `V0isize` isn't a bit-valid value of `[usize; 2]`
+   |                                            ^^^^^^ The size of `V0isize` is smaller than the size of `[usize; 2]`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
@@ -398,7 +398,7 @@ error[E0277]: `u8` cannot be safely transmuted into `V0usize` in the defining sc
   --> $DIR/primitive_reprs_should_have_correct_length.rs:152:44
    |
 LL |         assert::is_transmutable::<Smaller, Current, Context>();
-   |                                            ^^^^^^^ At least one value of `u8` isn't a bit-valid value of `V0usize`
+   |                                            ^^^^^^^ The size of `u8` is smaller than the size of `V0usize`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
@@ -420,7 +420,7 @@ error[E0277]: `V0usize` cannot be safely transmuted into `[usize; 2]` in the def
   --> $DIR/primitive_reprs_should_have_correct_length.rs:154:44
    |
 LL |         assert::is_transmutable::<Current, Larger, Context>();
-   |                                            ^^^^^^ At least one value of `V0usize` isn't a bit-valid value of `[usize; 2]`
+   |                                            ^^^^^^ The size of `V0usize` is smaller than the size of `[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
@@ -24,7 +24,7 @@ error[E0277]: `u128` cannot be safely transmuted into `void::repr_rust` in the d
   --> $DIR/should_require_well_defined_layout.rs:29:47
    |
 LL |         assert::is_maybe_transmutable::<u128, repr_rust>();
-   |                                               ^^^^^^^^^ `u128` does not have a well-specified layout
+   |                                               ^^^^^^^^^ `void::repr_rust` does not have a well-specified layout
    |
 note: required by a bound in `is_maybe_transmutable`
   --> $DIR/should_require_well_defined_layout.rs:14:14
@@ -68,7 +68,7 @@ error[E0277]: `u128` cannot be safely transmuted into `singleton::repr_rust` in
   --> $DIR/should_require_well_defined_layout.rs:35:47
    |
 LL |         assert::is_maybe_transmutable::<u128, repr_rust>();
-   |                                               ^^^^^^^^^ `u128` does not have a well-specified layout
+   |                                               ^^^^^^^^^ `singleton::repr_rust` does not have a well-specified layout
    |
 note: required by a bound in `is_maybe_transmutable`
   --> $DIR/should_require_well_defined_layout.rs:14:14
@@ -112,7 +112,7 @@ error[E0277]: `u128` cannot be safely transmuted into `duplex::repr_rust` in the
   --> $DIR/should_require_well_defined_layout.rs:41:47
    |
 LL |         assert::is_maybe_transmutable::<u128, repr_rust>();
-   |                                               ^^^^^^^^^ `u128` does not have a well-specified layout
+   |                                               ^^^^^^^^^ `duplex::repr_rust` does not have a well-specified layout
    |
 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
@@ -2,7 +2,7 @@ error[E0277]: `Src` cannot be safely transmuted into `Dst` in the defining scope
   --> $DIR/should_pad_variants.rs:44:36
    |
 LL |     assert::is_transmutable::<Src, Dst, Context>();
-   |                                    ^^^ At least one value of `Src` isn't a bit-valid value of `Dst`
+   |                                    ^^^ The size of `Src` is smaller than the size of `Dst`
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/should_pad_variants.rs:13: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
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
diff --git a/tests/ui/transmutability/unions/should_pad_variants.stderr b/tests/ui/transmutability/unions/should_pad_variants.stderr
diff --git a/tests/ui/transmute/transmute-padding-ice.stderr b/tests/ui/transmute/transmute-padding-ice.stderr

Original file line number	Diff line number	Diff line change
`@@ -329,7 +329,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {`
`329`	`329`	`)`
`330`	`330`	`};`
`331`	`331`
`332`		`- // // FIXME(bryangarza): Check src.mutability or dst.mutability to know whether dst -> src obligation is needed`
	`332`	`+ // FIXME(bryangarza): Check src.mutability or dst.mutability to know whether dst -> src obligation is needed`
`333`	`333`	`Ok(vec![make_obl(src.ty, dst.ty), make_obl(dst.ty, src.ty)])`
`334`	`334`	`}`
`335`	`335`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-#![feature(alloc_layout_extra, decl_macro, iterator_try_reduce, never_type)]`
	`1`	`+#![feature(alloc_layout_extra, decl_macro, iterator_try_reduce, never_type, let_chains)]`
`2`	`2`	`#![allow(dead_code, unused_variables)]`
`3`	`3`	`#![deny(rustc::untranslatable_diagnostic)]`
`4`	`4`	`#![deny(rustc::diagnostic_outside_of_impl)]`
Original file line number	Diff line number	Diff line change
@@ -23,7 +23,7 @@ error[E0277]: `u128` cannot be safely transmuted into `[String; 0]` in the defin
`23`	`23`	`--> $DIR/should_require_well_defined_layout.rs:27:47`
`24`	`24`	`\|`
`25`	`25`	`LL \| assert::is_maybe_transmutable::<u128, repr_rust>();`
`26`		- \| ^^^^^^^^^ `u128` does not have a well-specified layout
	`26`	+ \| ^^^^^^^^^ `[String; 0]` does not have a well-specified layout
`27`	`27`	`\|`
`28`	`28`	note: required by a bound in `is_maybe_transmutable`
`29`	`29`	`--> $DIR/should_require_well_defined_layout.rs:13:14`
@@ -65,7 +65,7 @@ error[E0277]: `u128` cannot be safely transmuted into `[String; 1]` in the defin
`65`	`65`	`--> $DIR/should_require_well_defined_layout.rs:33:47`
`66`	`66`	`\|`
`67`	`67`	`LL \| assert::is_maybe_transmutable::<u128, repr_rust>();`
`68`		- \| ^^^^^^^^^ `u128` does not have a well-specified layout
	`68`	+ \| ^^^^^^^^^ `[String; 1]` does not have a well-specified layout
`69`	`69`	`\|`
`70`	`70`	note: required by a bound in `is_maybe_transmutable`
`71`	`71`	`--> $DIR/should_require_well_defined_layout.rs:13:14`
@@ -107,7 +107,7 @@ error[E0277]: `u128` cannot be safely transmuted into `[String; 2]` in the defin
`107`	`107`	`--> $DIR/should_require_well_defined_layout.rs:39:47`
`108`	`108`	`\|`
`109`	`109`	`LL \| assert::is_maybe_transmutable::<u128, repr_rust>();`
`110`		- \| ^^^^^^^^^ `u128` does not have a well-specified layout
	`110`	+ \| ^^^^^^^^^ `[String; 2]` does not have a well-specified layout
`111`	`111`	`\|`
`112`	`112`	note: required by a bound in `is_maybe_transmutable`
`113`	`113`	`--> $DIR/should_require_well_defined_layout.rs:13:14`
Original file line number	Diff line number	Diff line change
@@ -24,7 +24,7 @@ error[E0277]: `V0i8` cannot be safely transmuted into `u16` in the defining scop
`24`	`24`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:50:44`
`25`	`25`	`\|`
`26`	`26`	`LL \| assert::is_transmutable::<Current, Larger, Context>();`
`27`		- \| ^^^^^^ At least one value of `V0i8` isn't a bit-valid value of `u16`
	`27`	+ \| ^^^^^^ The size of `V0i8` is smaller than the size of `u16`
`28`	`28`	`\|`
`29`	`29`	note: required by a bound in `is_transmutable`
`30`	`30`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
@@ -68,7 +68,7 @@ error[E0277]: `V0u8` cannot be safely transmuted into `u16` in the defining scop
`68`	`68`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:58:44`
`69`	`69`	`\|`
`70`	`70`	`LL \| assert::is_transmutable::<Current, Larger, Context>();`
`71`		- \| ^^^^^^ At least one value of `V0u8` isn't a bit-valid value of `u16`
	`71`	+ \| ^^^^^^ The size of `V0u8` is smaller than the size of `u16`
`72`	`72`	`\|`
`73`	`73`	note: required by a bound in `is_transmutable`
`74`	`74`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
@@ -90,7 +90,7 @@ error[E0277]: `u8` cannot be safely transmuted into `V0i16` in the defining scop
`90`	`90`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:72:44`
`91`	`91`	`\|`
`92`	`92`	`LL \| assert::is_transmutable::<Smaller, Current, Context>();`
`93`		- \| ^^^^^^^ At least one value of `u8` isn't a bit-valid value of `V0i16`
	`93`	+ \| ^^^^^^^ The size of `u8` is smaller than the size of `V0i16`
`94`	`94`	`\|`
`95`	`95`	note: required by a bound in `is_transmutable`
`96`	`96`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
@@ -112,7 +112,7 @@ error[E0277]: `V0i16` cannot be safely transmuted into `u32` in the defining sco
`112`	`112`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:74:44`
`113`	`113`	`\|`
`114`	`114`	`LL \| assert::is_transmutable::<Current, Larger, Context>();`
`115`		- \| ^^^^^^ At least one value of `V0i16` isn't a bit-valid value of `u32`
	`115`	+ \| ^^^^^^ The size of `V0i16` is smaller than the size of `u32`
`116`	`116`	`\|`
`117`	`117`	note: required by a bound in `is_transmutable`
`118`	`118`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
@@ -134,7 +134,7 @@ error[E0277]: `u8` cannot be safely transmuted into `V0u16` in the defining scop
`134`	`134`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:80:44`
`135`	`135`	`\|`
`136`	`136`	`LL \| assert::is_transmutable::<Smaller, Current, Context>();`
`137`		- \| ^^^^^^^ At least one value of `u8` isn't a bit-valid value of `V0u16`
	`137`	+ \| ^^^^^^^ The size of `u8` is smaller than the size of `V0u16`
`138`	`138`	`\|`
`139`	`139`	note: required by a bound in `is_transmutable`
`140`	`140`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
@@ -156,7 +156,7 @@ error[E0277]: `V0u16` cannot be safely transmuted into `u32` in the defining sco
`156`	`156`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:82:44`
`157`	`157`	`\|`
`158`	`158`	`LL \| assert::is_transmutable::<Current, Larger, Context>();`
`159`		- \| ^^^^^^ At least one value of `V0u16` isn't a bit-valid value of `u32`
	`159`	+ \| ^^^^^^ The size of `V0u16` is smaller than the size of `u32`
`160`	`160`	`\|`
`161`	`161`	note: required by a bound in `is_transmutable`
`162`	`162`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
@@ -178,7 +178,7 @@ error[E0277]: `u16` cannot be safely transmuted into `V0i32` in the defining sco
`178`	`178`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:96:44`
`179`	`179`	`\|`
`180`	`180`	`LL \| assert::is_transmutable::<Smaller, Current, Context>();`
`181`		- \| ^^^^^^^ At least one value of `u16` isn't a bit-valid value of `V0i32`
	`181`	+ \| ^^^^^^^ The size of `u16` is smaller than the size of `V0i32`
`182`	`182`	`\|`
`183`	`183`	note: required by a bound in `is_transmutable`
`184`	`184`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
@@ -200,7 +200,7 @@ error[E0277]: `V0i32` cannot be safely transmuted into `u64` in the defining sco
`200`	`200`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:98:44`
`201`	`201`	`\|`
`202`	`202`	`LL \| assert::is_transmutable::<Current, Larger, Context>();`
`203`		- \| ^^^^^^ At least one value of `V0i32` isn't a bit-valid value of `u64`
	`203`	+ \| ^^^^^^ The size of `V0i32` is smaller than the size of `u64`
`204`	`204`	`\|`
`205`	`205`	note: required by a bound in `is_transmutable`
`206`	`206`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
@@ -222,7 +222,7 @@ error[E0277]: `u16` cannot be safely transmuted into `V0u32` in the defining sco
`222`	`222`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:104:44`
`223`	`223`	`\|`
`224`	`224`	`LL \| assert::is_transmutable::<Smaller, Current, Context>();`
`225`		- \| ^^^^^^^ At least one value of `u16` isn't a bit-valid value of `V0u32`
	`225`	+ \| ^^^^^^^ The size of `u16` is smaller than the size of `V0u32`
`226`	`226`	`\|`
`227`	`227`	note: required by a bound in `is_transmutable`
`228`	`228`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
@@ -244,7 +244,7 @@ error[E0277]: `V0u32` cannot be safely transmuted into `u64` in the defining sco
`244`	`244`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:106:44`
`245`	`245`	`\|`
`246`	`246`	`LL \| assert::is_transmutable::<Current, Larger, Context>();`
`247`		- \| ^^^^^^ At least one value of `V0u32` isn't a bit-valid value of `u64`
	`247`	+ \| ^^^^^^ The size of `V0u32` is smaller than the size of `u64`
`248`	`248`	`\|`
`249`	`249`	note: required by a bound in `is_transmutable`
`250`	`250`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
@@ -266,7 +266,7 @@ error[E0277]: `u32` cannot be safely transmuted into `V0i64` in the defining sco
`266`	`266`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:120:44`
`267`	`267`	`\|`
`268`	`268`	`LL \| assert::is_transmutable::<Smaller, Current, Context>();`
`269`		- \| ^^^^^^^ At least one value of `u32` isn't a bit-valid value of `V0i64`
	`269`	+ \| ^^^^^^^ The size of `u32` is smaller than the size of `V0i64`
`270`	`270`	`\|`
`271`	`271`	note: required by a bound in `is_transmutable`
`272`	`272`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
@@ -288,7 +288,7 @@ error[E0277]: `V0i64` cannot be safely transmuted into `u128` in the defining sc
`288`	`288`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:122:44`
`289`	`289`	`\|`
`290`	`290`	`LL \| assert::is_transmutable::<Current, Larger, Context>();`
`291`		- \| ^^^^^^ At least one value of `V0i64` isn't a bit-valid value of `u128`
	`291`	+ \| ^^^^^^ The size of `V0i64` is smaller than the size of `u128`
`292`	`292`	`\|`
`293`	`293`	note: required by a bound in `is_transmutable`
`294`	`294`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
@@ -310,7 +310,7 @@ error[E0277]: `u32` cannot be safely transmuted into `V0u64` in the defining sco
`310`	`310`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:128:44`
`311`	`311`	`\|`
`312`	`312`	`LL \| assert::is_transmutable::<Smaller, Current, Context>();`
`313`		- \| ^^^^^^^ At least one value of `u32` isn't a bit-valid value of `V0u64`
	`313`	+ \| ^^^^^^^ The size of `u32` is smaller than the size of `V0u64`
`314`	`314`	`\|`
`315`	`315`	note: required by a bound in `is_transmutable`
`316`	`316`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
@@ -332,7 +332,7 @@ error[E0277]: `V0u64` cannot be safely transmuted into `u128` in the defining sc
`332`	`332`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:130:44`
`333`	`333`	`\|`
`334`	`334`	`LL \| assert::is_transmutable::<Current, Larger, Context>();`
`335`		- \| ^^^^^^ At least one value of `V0u64` isn't a bit-valid value of `u128`
	`335`	+ \| ^^^^^^ The size of `V0u64` is smaller than the size of `u128`
`336`	`336`	`\|`
`337`	`337`	note: required by a bound in `is_transmutable`
`338`	`338`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
@@ -354,7 +354,7 @@ error[E0277]: `u8` cannot be safely transmuted into `V0isize` in the defining sc
`354`	`354`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:144:44`
`355`	`355`	`\|`
`356`	`356`	`LL \| assert::is_transmutable::<Smaller, Current, Context>();`
`357`		- \| ^^^^^^^ At least one value of `u8` isn't a bit-valid value of `V0isize`
	`357`	+ \| ^^^^^^^ The size of `u8` is smaller than the size of `V0isize`
`358`	`358`	`\|`
`359`	`359`	note: required by a bound in `is_transmutable`
`360`	`360`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
@@ -376,7 +376,7 @@ error[E0277]: `V0isize` cannot be safely transmuted into `[usize; 2]` in the def
`376`	`376`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:146:44`
`377`	`377`	`\|`
`378`	`378`	`LL \| assert::is_transmutable::<Current, Larger, Context>();`
`379`		- \| ^^^^^^ At least one value of `V0isize` isn't a bit-valid value of `[usize; 2]`
	`379`	+ \| ^^^^^^ The size of `V0isize` is smaller than the size of `[usize; 2]`
`380`	`380`	`\|`
`381`	`381`	note: required by a bound in `is_transmutable`
`382`	`382`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
@@ -398,7 +398,7 @@ error[E0277]: `u8` cannot be safely transmuted into `V0usize` in the defining sc
`398`	`398`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:152:44`
`399`	`399`	`\|`
`400`	`400`	`LL \| assert::is_transmutable::<Smaller, Current, Context>();`
`401`		- \| ^^^^^^^ At least one value of `u8` isn't a bit-valid value of `V0usize`
	`401`	+ \| ^^^^^^^ The size of `u8` is smaller than the size of `V0usize`
`402`	`402`	`\|`
`403`	`403`	note: required by a bound in `is_transmutable`
`404`	`404`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
@@ -420,7 +420,7 @@ error[E0277]: `V0usize` cannot be safely transmuted into `[usize; 2]` in the def
`420`	`420`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:154:44`
`421`	`421`	`\|`
`422`	`422`	`LL \| assert::is_transmutable::<Current, Larger, Context>();`
`423`		- \| ^^^^^^ At least one value of `V0usize` isn't a bit-valid value of `[usize; 2]`
	`423`	+ \| ^^^^^^ The size of `V0usize` is smaller than the size of `[usize; 2]`
`424`	`424`	`\|`
`425`	`425`	note: required by a bound in `is_transmutable`
`426`	`426`	`--> $DIR/primitive_reprs_should_have_correct_length.rs:12:14`
Original file line number	Diff line number	Diff line change
@@ -24,7 +24,7 @@ error[E0277]: `u128` cannot be safely transmuted into `void::repr_rust` in the d
`24`	`24`	`--> $DIR/should_require_well_defined_layout.rs:29:47`
`25`	`25`	`\|`
`26`	`26`	`LL \| assert::is_maybe_transmutable::<u128, repr_rust>();`
`27`		- \| ^^^^^^^^^ `u128` does not have a well-specified layout
	`27`	+ \| ^^^^^^^^^ `void::repr_rust` does not have a well-specified layout
`28`	`28`	`\|`
`29`	`29`	note: required by a bound in `is_maybe_transmutable`
`30`	`30`	`--> $DIR/should_require_well_defined_layout.rs:14:14`
@@ -68,7 +68,7 @@ error[E0277]: `u128` cannot be safely transmuted into `singleton::repr_rust` in
`68`	`68`	`--> $DIR/should_require_well_defined_layout.rs:35:47`
`69`	`69`	`\|`
`70`	`70`	`LL \| assert::is_maybe_transmutable::<u128, repr_rust>();`
`71`		- \| ^^^^^^^^^ `u128` does not have a well-specified layout
	`71`	+ \| ^^^^^^^^^ `singleton::repr_rust` does not have a well-specified layout
`72`	`72`	`\|`
`73`	`73`	note: required by a bound in `is_maybe_transmutable`
`74`	`74`	`--> $DIR/should_require_well_defined_layout.rs:14:14`
@@ -112,7 +112,7 @@ error[E0277]: `u128` cannot be safely transmuted into `duplex::repr_rust` in the
`112`	`112`	`--> $DIR/should_require_well_defined_layout.rs:41:47`
`113`	`113`	`\|`
`114`	`114`	`LL \| assert::is_maybe_transmutable::<u128, repr_rust>();`
`115`		- \| ^^^^^^^^^ `u128` does not have a well-specified layout
	`115`	+ \| ^^^^^^^^^ `duplex::repr_rust` does not have a well-specified layout
`116`	`116`	`\|`
`117`	`117`	note: required by a bound in `is_maybe_transmutable`
`118`	`118`	`--> $DIR/should_require_well_defined_layout.rs:14:14`
Original file line number	Diff line number	Diff line change
@@ -2,7 +2,7 @@ error[E0277]: `Src` cannot be safely transmuted into `Dst` in the defining scope
`2`	`2`	`--> $DIR/should_pad_variants.rs:44:36`
`3`	`3`	`\|`
`4`	`4`	`LL \| assert::is_transmutable::<Src, Dst, Context>();`
`5`		- \| ^^^ At least one value of `Src` isn't a bit-valid value of `Dst`
	`5`	+ \| ^^^ The size of `Src` is smaller than the size of `Dst`
`6`	`6`	`\|`
`7`	`7`	note: required by a bound in `is_transmutable`
`8`	`8`	`--> $DIR/should_pad_variants.rs:13:14`