Fix transmutability type mismatch bug

compiler/rustc_middle/src/ty/context/impl_interner.rs

@@ -819,6 +819,7 @@ bidirectional_lang_item_map! {
     FnMut,
     FnOnce,
     FnPtrTrait,
+    Freeze,
     FusedIterator,
     Future,
     Iterator,

compiler/rustc_next_trait_solver/src/delegate.rs

@@ -2,10 +2,13 @@ use std::fmt::Debug;
 use std::ops::Deref;
 
 use rustc_type_ir::solve::{
-    Certainty, ComputeGoalFastPathOutcome, FetchEligibleAssocItemResponse, Goal, NoSolution,
+    ComputeGoalFastPathOutcome, FetchEligibleAssocItemResponse, Goal, NoSolution,
     VisibleForLeakCheck,
 };
-use rustc_type_ir::{self as ty, CanonicalizerState, Const, InferCtxtLike, Interner, TypeFoldable};
+use rustc_type_ir::transmute::Answer;
+use rustc_type_ir::{
+    self as ty, CanonicalizerState, Const, InferCtxtLike, Interner, Region, TypeFoldable,
+};
 
 /// `SolverDelegate` is one of the two traits in the `rustc_type_ir` shared abstraction layer
 /// between rustc and rust-analyzer abstracting over the [InferCtxt][inferctxt-doc], which had to be
@@ -113,7 +116,7 @@ pub trait SolverDelegate: Deref<Target = Self::Infcx> + Sized {
         src: <Self::Interner as Interner>::Ty,
         dst: <Self::Interner as Interner>::Ty,
         assume: Const<Self::Interner>,
-    ) -> Result<Certainty, NoSolution>;
+    ) -> Result<Answer<Region<Self::Interner>, <Self::Interner as Interner>::Ty>, NoSolution>;
 
     /// Obtain canonicalizer state, either by allocating it afresh (the default) or by reusing
     /// previously allocated state.

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -16,6 +16,7 @@ use rustc_type_ir::solve::{
     NoSolutionOrRerunNonErased, OpaqueTypesJank, QueryResultOrRerunNonErased, RerunCondition,
     RerunNonErased, RerunReason, RerunResultExt, SmallCopySet, TyOrConstInferVar,
 };
+use rustc_type_ir::transmute::Answer;
 use rustc_type_ir::{
     self as ty, ClauseKind, Const, InferCtxtLike, Interner, MayBeErased, OpaqueTypeKey,
     PredicateKind, PredicateProxy, Region, RegionVid, TypeFoldable, TypeSuperVisitable,
@@ -1565,7 +1566,7 @@ where
         src: I::Ty,
         dst: I::Ty,
         assume: Const<I>,
-    ) -> Result<Certainty, NoSolution> {
+    ) -> Result<Answer<Region<I>, I::Ty>, NoSolution> {
         self.delegate.is_transmutable(dst, src, assume)
     }
 

compiler/rustc_next_trait_solver/src/solve/mod.rs

@@ -22,8 +22,11 @@ mod trait_goals;
 
 use derive_where::derive_where;
 use rustc_type_ir::inherent::*;
+use rustc_type_ir::lang_items::SolverTraitLangItem;
 pub use rustc_type_ir::solve::*;
-use rustc_type_ir::{self as ty, Const, Interner, Region, TypeVisitableExt};
+use rustc_type_ir::transmute::Condition;
+use rustc_type_ir::{self as ty, Const, Interner, Region, TraitClause, TypeVisitableExt, Upcast};
+use thin_vec::{ThinVec, thin_vec};
 use tracing::instrument;
 
 pub use self::eval_ctxt::{
@@ -491,3 +494,42 @@ pub struct GoalEvaluation<I: Interner> {
     /// before rerunning it.
     pub stalled_on: Option<GoalStalledOn<I>>,
 }
+
+/// Flatten the `Condition` tree into a conjunction of predicates.
+#[instrument(level = "debug", skip(interner, predicate))]
+pub fn flatten_answer_tree<I: Interner>(
+    interner: I,
+    predicate: TraitClause<I>,
+    cond: Condition<Region<I>, I::Ty>,
+) -> ThinVec<I::Predicate> {
+    match cond {
+        // FIXME(bryangarza): Add separate `IfAny` case, instead of treating as `IfAll`
+        // Not possible until the trait solver supports disjunctions of obligations
+        Condition::IfAll(conds) | Condition::IfAny(conds) => conds
+            .into_iter()
+            .flat_map(|cond| flatten_answer_tree(interner, predicate, cond))
+            .collect(),
+        Condition::Immutable { ty } => {
+            let trait_ref = ty::TraitRef::new(
+                interner,
+                interner.require_trait_lang_item(SolverTraitLangItem::Freeze),
+                [I::GenericArg::from(ty)],
+            );
+            thin_vec![trait_ref.upcast(interner)]
+        }
+        Condition::Outlives { long, short } => {
+            let outlives = ty::OutlivesClause(long, short);
+            thin_vec![outlives.upcast(interner)]
+        }
+        Condition::Transmutable { src, dst } => {
+            let transmute_trait = predicate.def_id();
+            let assume = predicate.trait_ref.args.const_at(2);
+            let trait_ref = ty::TraitRef::new(
+                interner,
+                transmute_trait,
+                [I::GenericArg::from(dst), I::GenericArg::from(src), I::GenericArg::from(assume)],
+            );
+            thin_vec![trait_ref.upcast(interner)]
+        }
+    }
+}

compiler/rustc_next_trait_solver/src/solve/trait_goals.rs

@@ -24,7 +24,7 @@ use crate::solve::assembly::{
 use crate::solve::inspect::ProbeKind;
 use crate::solve::{
     BuiltinImplSource, CandidateSource, Certainty, EvalCtxt, Goal, GoalSource, MaybeCause,
-    MergeCandidateInfo, NoSolution, ParamEnvSource, StalledOnCoroutines,
+    MergeCandidateInfo, NoSolution, ParamEnvSource, StalledOnCoroutines, flatten_answer_tree,
     has_only_region_constraints,
 };
 
@@ -656,6 +656,8 @@ where
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, Self>,
     ) -> Result<Candidate<I>, NoSolutionOrRerunNonErased> {
+        use rustc_type_ir::transmute::Answer;
+
         if goal.predicate.polarity != ty::ClausePolarity::Positive {
             return Err(NoSolution.into());
         }
@@ -678,11 +680,28 @@ where
                     goal.predicate.trait_ref.args.const_at(2),
                 )?;
 
-                let certainty = ecx.is_transmutable(
+                let answer = ecx.is_transmutable(
                     goal.predicate.trait_ref.args.type_at(0),
                     goal.predicate.trait_ref.args.type_at(1),
                     assume,
                 )?;
+
+                let certainty = match answer {
+                    Answer::No(_) => return Err(NoSolution.into()),
+                    Answer::Yes => Certainty::Yes,
+                    Answer::If(cond) => {
+                        let tcx = ecx.cx();
+                        ecx.add_goals(
+                            GoalSource::Misc,
+                            flatten_answer_tree(tcx, goal.predicate, cond)
+                                .into_iter()
+                                .map(|predicate| Goal::new(tcx, goal.param_env, predicate)),
+                        )?;
+
+                        Certainty::Yes
+                    }
+                };
+
                 ecx.evaluate_added_goals_and_make_canonical_response(certainty)
             },
         )

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

@@ -31,6 +31,7 @@ use rustc_middle::ty::print::{
     PrintPolyTraitClauseExt, PrintPolyTraitRefExt as _, PrintTraitClauseExt as _,
     PrintTraitRefExt as _, with_forced_trimmed_paths,
 };
+use rustc_middle::ty::transmute::{Answer, Reason};
 use rustc_middle::ty::{
     self, GenericArgKind, GenericParamDefKind, TraitRef, Ty, TyCtxt, TypeFoldable, TypeFolder,
     TypeSuperFoldable, TypeVisitableExt, Unnormalized, Upcast,
@@ -3253,7 +3254,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 trait_ref.args.type_at(0),
                 assume,
             ),
-            rustc_transmute::Answer::Yes,
+            Answer::Yes,
         );
 
         // If the normalized check unexpectedly passes, fall back to root obligation for reporting.
@@ -3274,7 +3275,6 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         trait_pred: ty::PolyTraitClause<'tcx>,
         span: Span,
     ) -> GetSafeTransmuteErrorAndReason {
-        use rustc_transmute::Answer;
         self.probe(|_| {
             // We don't assemble a transmutability candidate for types that are generic
             // and we should have ambiguity for types that still have non-region infer.
@@ -3311,69 +3311,61 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             {
                 Answer::No(reason) => {
                     let safe_transmute_explanation = match reason {
-                        rustc_transmute::Reason::SrcIsNotYetSupported => {
+                        Reason::SrcIsNotYetSupported => {
                             format!("analyzing the transmutability of `{src}` is not yet supported")
                         }
-                        rustc_transmute::Reason::DstIsNotYetSupported => {
+                        Reason::DstIsNotYetSupported => {
                             format!("analyzing the transmutability of `{dst}` is not yet supported")
                         }
-                        rustc_transmute::Reason::DstIsBitIncompatible => {
+                        Reason::DstIsBitIncompatible => {
                             format!(
                                 "at least one value of `{src}` isn't a bit-valid value of `{dst}`"
                             )
                         }
-                        rustc_transmute::Reason::DstUninhabited => {
+                        Reason::DstUninhabited => {
                             format!("`{dst}` is uninhabited")
                         }
-                        rustc_transmute::Reason::DstMayHaveSafetyInvariants => {
+                        Reason::DstMayHaveSafetyInvariants => {
                             format!("`{dst}` may carry safety invariants")
                         }
-                        rustc_transmute::Reason::DstIsTooBig => {
+                        Reason::DstIsTooBig => {
                             format!("the size of `{src}` is smaller than the size of `{dst}`")
                         }
-                        rustc_transmute::Reason::DstRefIsTooBig {
-                            src,
-                            src_size,
-                            dst,
-                            dst_size,
-                        } => {
+                        Reason::DstRefIsTooBig { src, src_size, dst, dst_size } => {
                             format!(
                                 "the size of `{src}` ({src_size} bytes) \
                         is smaller than that of `{dst}` ({dst_size} bytes)"
                             )
                         }
-                        rustc_transmute::Reason::SrcSizeOverflow => {
+                        Reason::SrcSizeOverflow => {
                             format!(
                                 "values of the type `{src}` are too big for the target architecture"
                             )
                         }
-                        rustc_transmute::Reason::DstSizeOverflow => {
+                        Reason::DstSizeOverflow => {
                             format!(
                                 "values of the type `{dst}` are too big for the target architecture"
                             )
                         }
-                        rustc_transmute::Reason::DstHasStricterAlignment {
-                            src_min_align,
-                            dst_min_align,
-                        } => {
+                        Reason::DstHasStricterAlignment { src_min_align, dst_min_align } => {
                             format!(
                                 "the minimum alignment of `{src}` ({src_min_align}) should be \
                                  greater than that of `{dst}` ({dst_min_align})"
                             )
                         }
-                        rustc_transmute::Reason::DstIsMoreUnique => {
+                        Reason::DstIsMoreUnique => {
                             format!(
                                 "`{src}` is a shared reference, but `{dst}` is a unique reference"
                             )
                         }
                         // Already reported by rustc
-                        rustc_transmute::Reason::TypeError => {
+                        Reason::TypeError => {
                             return GetSafeTransmuteErrorAndReason::Silent;
                         }
-                        rustc_transmute::Reason::SrcLayoutUnknown => {
+                        Reason::SrcLayoutUnknown => {
                             format!("`{src}` has an unknown layout")
                         }
-                        rustc_transmute::Reason::DstLayoutUnknown => {
+                        Reason::DstLayoutUnknown => {
                             format!("`{dst}` has an unknown layout")
                         }
                     };

compiler/rustc_trait_selection/src/solve/delegate.rs

@@ -19,15 +19,17 @@ use rustc_infer::traits::solve::{
 };
 use rustc_lint_defs::builtin::RECURSION_DEPTH_EXCEEDING_LIMIT;
 use rustc_middle::traits::query::NoSolution;
-use rustc_middle::traits::solve::{Certainty, MaybeInfo};
+use rustc_middle::traits::solve::MaybeInfo;
 use rustc_middle::ty::print::{FmtPrinter, Print};
+use rustc_middle::ty::transmute::Answer;
 use rustc_middle::ty::{
-    self, CanonicalizerState, MayBeErased, Ty, TyCtxt, TypeFlags, TypeFoldable, TypeSuperVisitable,
-    TypeVisitable, TypeVisitableExt, TypeVisitor, TypingMode,
+    self, CanonicalizerState, MayBeErased, Region, Ty, TyCtxt, TypeFlags, TypeFoldable,
+    TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor, TypingMode,
 };
 use rustc_next_trait_solver::solve::{GoalStalledOn, GoalStalledOnOpaques, TyOrConstInferVar};
 use rustc_span::{DUMMY_SP, Span};
 use rustc_structures::Limit;
+use rustc_transmute::TransmuteTypeEnv;
 use thin_vec::{ThinVec, thin_vec};
 
 use super::inspect::InferCtxtProofTreeExt;
@@ -491,20 +493,14 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
         src: Ty<'tcx>,
         dst: Ty<'tcx>,
         assume: ty::Const<'tcx>,
-    ) -> Result<Certainty, NoSolution> {
+    ) -> Result<Answer<Region<'tcx>, Ty<'tcx>>, NoSolution> {
         // Erase regions because we compute layouts in `rustc_transmute`,
         // which will ICE for region vars.
         let (dst, src) = self.tcx.erase_and_anonymize_regions((dst, src));
 
-        let Some(assume) = rustc_transmute::Assume::from_const(self.tcx, assume) else {
-            return Err(NoSolution);
-        };
-
-        // FIXME(transmutability): This really should be returning nested goals for `Answer::If*`
-        match rustc_transmute::TransmuteTypeEnv::new(self.0.tcx).is_transmutable(src, dst, assume) {
-            rustc_transmute::Answer::Yes => Ok(Certainty::Yes),
-            rustc_transmute::Answer::No(_) | rustc_transmute::Answer::If(_) => Err(NoSolution),
-        }
+        rustc_transmute::Assume::from_const(self.tcx, assume)
+            .map(|assume| TransmuteTypeEnv::new(self.0.tcx).is_transmutable(src, dst, assume))
+            .ok_or(NoSolution)
     }
 
     fn obtain_canonicalizer_state(&self) -> CanonicalizerState<Self::Interner> {