Safe Transmute: Return ambiguity instead of an error, when necessary

This patch updates a couple spots in the trait selection (in both solvers) to
return ambiguity instead of an error.

Author: bryangarza

compiler/rustc_trait_selection/src/solve/trait_goals.rs

@@ -602,9 +602,11 @@ impl<'tcx> assembly::GoalKind<'tcx> for TraitPredicate<'tcx> {
         let maybe_assume =
             rustc_transmute::Assume::from_const(ecx.tcx(), goal.param_env, args.const_at(3));
         let assume = match maybe_assume {
-            Some(Ok(assume)) => assume,
-            Some(Err(_guar)) => return Err(NoSolution),
-            None => return Err(NoSolution),
+            Ok(Some(assume)) => assume,
+            Ok(None) => {
+                return ecx.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS);
+            }
+            Err(_guar) => return Err(NoSolution),
         };
 
         let certainty = ecx.is_transmutable(

compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs

@@ -2897,9 +2897,9 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
         );
 
         let assume = match maybe_assume {
-            Some(Ok(assume)) => assume,
-            Some(Err(guar)) => return GetSafeTransmuteErrorAndReason::ErrorGuaranteed(guar),
-            None => return GetSafeTransmuteErrorAndReason::Ambiguous,
+            Ok(Some(assume)) => assume,
+            Ok(None) => return GetSafeTransmuteErrorAndReason::Ambiguous,
+            Err(guar) => return GetSafeTransmuteErrorAndReason::ErrorGuaranteed(guar),
         };
 
         match rustc_transmute::TransmuteTypeEnv::new(self.infcx).is_transmutable(
@@ -2945,7 +2945,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
                         format!("`{src}` is a shared reference, but `{dst}` is a unique reference")
                     }
                     // Already reported by rustc
-                    rustc_transmute::Reason::TypeError(guar) => {
+                    rustc_transmute::Reason::ErrorGuaranteed(guar) => {
                         return GetSafeTransmuteErrorAndReason::ErrorGuaranteed(guar);
                     }
                     rustc_transmute::Reason::SrcLayoutUnknown => {

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

@@ -340,12 +340,14 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         let predicate =
             self.tcx().erase_regions(self.tcx().erase_late_bound_regions(obligation.predicate));
 
-        let Some(Ok(assume)) = rustc_transmute::Assume::from_const(
+        let assume = match rustc_transmute::Assume::from_const(
             self.infcx.tcx,
             obligation.param_env,
             predicate.trait_ref.args.const_at(3),
-        ) else {
-            return Err(Unimplemented);
+        ) {
+            Ok(Some(assume)) => assume,
+            Ok(None) => return Ok(vec![]),
+            Err(_guar) => return Err(Unimplemented),
         };
 
         let dst = predicate.trait_ref.args.type_at(0);

compiler/rustc_transmute/src/lib.rs

@@ -59,7 +59,7 @@ pub enum Reason {
     /// Can't go from shared pointer to unique pointer
     DstIsMoreUnique,
     /// Encountered a type error
-    TypeError(ErrorGuaranteed),
+    ErrorGuaranteed(ErrorGuaranteed),
     /// The layout of src is unknown
     SrcLayoutUnknown,
     /// The layout of dst is unknown
@@ -124,17 +124,20 @@ mod rustc {
             tcx: TyCtxt<'tcx>,
             param_env: ParamEnv<'tcx>,
             c: Const<'tcx>,
-        ) -> Option<Result<Self, ErrorGuaranteed>> {
+        ) -> Result<Option<Self>, ErrorGuaranteed> {
             use rustc_middle::ty::ScalarInt;
             use rustc_middle::ty::TypeVisitableExt;
             use rustc_span::symbol::sym;
 
             let c = c.eval(tcx, param_env);
             if let Err(err) = c.error_reported() {
-                return Some(Err(err));
+                return Err(err);
             }
 
-            let adt_def = c.ty().ty_adt_def()?;
+            let adt_def = match c.ty().ty_adt_def() {
+                Some(adt_def) => adt_def,
+                None => return Ok(None),
+            };
 
             assert_eq!(
                 tcx.require_lang_item(LangItem::TransmuteOpts, None),
@@ -146,7 +149,7 @@ mod rustc {
             let variant = adt_def.non_enum_variant();
             let fields = match c.try_to_valtree() {
                 Some(ValTree::Branch(branch)) => branch,
-                _ => return None,
+                _ => return Ok(None),
             };
 
             let get_field = |name| {
@@ -159,7 +162,7 @@ mod rustc {
                 fields[field_idx].unwrap_leaf() == ScalarInt::TRUE
             };
 
-            Some(Ok(Self {
+            Ok(Some(Self {
                 alignment: get_field(sym::alignment),
                 lifetimes: get_field(sym::lifetimes),
                 safety: get_field(sym::safety),
@@ -169,6 +172,9 @@ mod rustc {
     }
 }
 
+// FIXME(bryangarza): This prevents `cargo build` from building.
+// Need to remove this dependency on `ErrorGuaranteed` so the crate can
+// build/test independently of rustc again.
 #[cfg(feature = "rustc")]
 pub use rustc::*;
 use rustc_span::ErrorGuaranteed;

compiler/rustc_transmute/src/maybe_transmutable/mod.rs

@@ -79,7 +79,7 @@ mod rustc {
 
             match (src, dst) {
                 (Err(Err::TypeError(guar)), _) | (_, Err(Err::TypeError(guar))) => {
-                    Answer::No(Reason::TypeError(guar))
+                    Answer::No(Reason::ErrorGuaranteed(guar))
                 }
                 (Err(Err::UnknownLayout), _) => Answer::No(Reason::SrcLayoutUnknown),
                 (_, Err(Err::UnknownLayout)) => Answer::No(Reason::DstLayoutUnknown),

tests/ui/transmutability/issue-110969.current.stderr renamed to tests/ui/transmutability/inconsistent-is-transmutable.current.stderr

@@ -1,11 +1,11 @@
 error[E0308]: mismatched types
-  --> $DIR/issue-110969.rs:26:74
+  --> $DIR/inconsistent-is-transmutable.rs:27:74
    |
 LL |         const FALSE: bool = assert::is_transmutable::<Src, Dst, Context, {}>();
    |                                                                          ^^ expected `Assume`, found `()`
 
 error[E0308]: mismatched types
-  --> $DIR/issue-110969.rs:26:29
+  --> $DIR/inconsistent-is-transmutable.rs:27:29
    |
 LL |         const FALSE: bool = assert::is_transmutable::<Src, Dst, Context, {}>();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `bool`, found `()`

tests/ui/transmutability/issue-110969.next.stderr renamed to tests/ui/transmutability/inconsistent-is-transmutable.next.stderr

@@ -1,11 +1,11 @@
 error[E0308]: mismatched types
-  --> $DIR/issue-110969.rs:26:74
+  --> $DIR/inconsistent-is-transmutable.rs:27:74
    |
 LL |         const FALSE: bool = assert::is_transmutable::<Src, Dst, Context, {}>();
    |                                                                          ^^ expected `Assume`, found `()`
 
 error[E0308]: mismatched types
-  --> $DIR/issue-110969.rs:26:29
+  --> $DIR/inconsistent-is-transmutable.rs:27:29
    |
 LL |         const FALSE: bool = assert::is_transmutable::<Src, Dst, Context, {}>();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `bool`, found `()`

tests/ui/transmutability/issue-110969.rs renamed to tests/ui/transmutability/inconsistent-is-transmutable.rs

@@ -1,6 +1,7 @@
 // check-fail
 // revisions: current next
 //[next] compile-flags: -Ztrait-solver=next
+// https://github.com/rust-lang/rust/issues/110969
 #![feature(adt_const_params, generic_const_exprs, transmutability)]
 #![allow(incomplete_features)]