Safe Transmute: Pass ErrorGuaranteed up to error reporting

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

@@ -4,6 +4,7 @@ use crate::dep_graph::TaskDepsRef;
 use crate::ty::query;
 use rustc_data_structures::sync::{self, Lock};
 use rustc_errors::Diagnostic;
+use rustc_errors::ErrorGuaranteed;
 #[cfg(not(parallel_compiler))]
 use std::cell::Cell;
 use std::mem;
@@ -153,3 +154,11 @@ where
 {
  with_context_opt(|opt_context| f(opt_context.map(|context| context.tcx)))
 }
+
+pub fn expect_compilation_to_fail() -> ErrorGuaranteed {
+ if let Some(guar) = with(|tcx| tcx.sess.is_compilation_going_to_fail()) {
+ guar
+ } else {
+ bug!("expect tcx.sess.is_compilation_going_to_fail() to return `Some`");
+ }
+}

compiler/rustc_middle/src/ty/visit.rs

@@ -59,15 +59,7 @@ pub trait TypeVisitableExt<'tcx>: TypeVisitable<TyCtxt<'tcx>> {
  self.has_type_flags(TypeFlags::HAS_ERROR)
  }
  fn error_reported(&self) -> Result<(), ErrorGuaranteed> {
- if self.references_error() {
- if let Some(reported) = ty::tls::with(|tcx| tcx.sess.is_compilation_going_to_fail()) {
- Err(reported)
- } else {
- bug!("expect tcx.sess.is_compilation_going_to_fail return `Some`");
- }
- } else {
- Ok(())
- }
+ if self.references_error() { Err(ty::tls::expect_compilation_to_fail()) } else { Ok(()) }
  }
  fn has_non_region_param(&self) -> bool {
  self.has_type_flags(TypeFlags::NEEDS_SUBST - TypeFlags::HAS_RE_PARAM)

compiler/rustc_trait_selection/src/solve/eval_ctxt.rs

@@ -672,7 +672,9 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
  rustc_transmute::Answer::No(_)
  | rustc_transmute::Answer::IfTransmutable { .. }
  | rustc_transmute::Answer::IfAll(_)
- | rustc_transmute::Answer::IfAny(_) => Err(NoSolution),
+ | rustc_transmute::Answer::IfAny(_)
+ // FIXME(bryangarza): Pass the `ErrorGuaranteed` along instead of losing it?
+ | rustc_transmute::Answer::Err(_) => Err(NoSolution),
  }
  }
 }

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

@@ -741,11 +741,17 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
  == 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(
+ match self.get_safe_transmute_error_and_reason(
  obligation.clone(),
  trait_ref,
  span,
- )
+ ) {
+ SafeTransmuteError::ShouldReport { err_msg, explanation } => {
+ (err_msg, Some(explanation))
+ }
+ // An error is guaranteed to already have been reported at this point, no need to continue
+ SafeTransmuteError::ErrorGuaranteed(_) => return,
+ }
  } else {
  (err_msg, None)
  };
@@ -1631,7 +1637,7 @@ trait InferCtxtPrivExt<'tcx> {
  obligation: Obligation<'tcx, ty::Predicate<'tcx>>,
  trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
  span: Span,
- ) -> (String, Option<String>);
+ ) -> SafeTransmuteError;
 }
 
 impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
@@ -2922,7 +2928,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
  obligation: Obligation<'tcx, ty::Predicate<'tcx>>,
  trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
  span: Span,
- ) -> (String, Option<String>) {
+ ) -> SafeTransmuteError {
  // Erase regions because layout code doesn't particularly care about regions.
  let trait_ref = self.tcx.erase_regions(self.tcx.erase_late_bound_regions(trait_ref));
 
@@ -2944,10 +2950,10 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
  rustc_transmute::Answer::No(reason) => {
  let dst = trait_ref.substs.type_at(0);
  let src = trait_ref.substs.type_at(1);
- let custom_err_msg = format!(
+ let err_msg = format!(
  "`{src}` cannot be safely transmuted into `{dst}` in the defining scope of `{scope}`"
  );
- let reason_msg = match reason {
+ let explanation = match reason {
  rustc_transmute::Reason::SrcIsUnspecified => {
  format!("`{src}` does not have a well-specified layout")
  }
@@ -2968,13 +2974,14 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
  format!("The size of `{src}` is smaller than the size of `{dst}`")
  }
  };
- (custom_err_msg, Some(reason_msg))
+ SafeTransmuteError::ShouldReport { err_msg, explanation }
  }
  // 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",
  ),
+ rustc_transmute::Answer::Err(guar) => SafeTransmuteError::ErrorGuaranteed(guar),
  _ => span_bug!(span, "Unsupported rustc_transmute::Reason variant"),
  }
  }
@@ -3103,3 +3110,8 @@ pub enum DefIdOrName {
  DefId(DefId),
  Name(&'static str),
 }
+
+enum SafeTransmuteError {
+ ShouldReport { err_msg: String, explanation: String },
+ ErrorGuaranteed(ErrorGuaranteed),
+}

compiler/rustc_transmute/src/layout/tree.rs

@@ -187,15 +187,15 @@ pub(crate) mod rustc {
  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,
+ Unknown(ErrorGuaranteed),
  TypeError(ErrorGuaranteed),
  }
 
  impl<'tcx> From<LayoutError<'tcx>> for Err {
  fn from(err: LayoutError<'tcx>) -> Self {
+ let guar = rustc_middle::ty::tls::expect_compilation_to_fail();
  match err {
- LayoutError::Unknown(..) => Self::Unknown,
+ LayoutError::Unknown(..) => Self::Unknown(guar),
  err => unimplemented!("{:?}", err),
  }
  }

compiler/rustc_transmute/src/lib.rs

@@ -39,6 +39,9 @@ where
 
  /// `Src` is transmutable into `Dst` if any of the enclosed requirements are met.
  IfAny(Vec<Answer<R>>),
+
+ /// Encountered an error during safe transmute computation
+ Err(ErrorGuaranteed),
 }
 
 /// Answers: Why wasn't the source type transmutable into the destination type?
@@ -162,3 +165,4 @@ mod rustc {
 
 #[cfg(feature = "rustc")]
 pub use rustc::*;
+use rustc_span::ErrorGuaranteed;

compiler/rustc_transmute/src/maybe_transmutable/mod.rs

@@ -75,12 +75,10 @@ mod rustc {
  let dst = Tree::from_ty(dst, context);
 
  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::TypeError(guar)), _) => Err(Answer::Err(guar)),
+ (_, Err(Err::TypeError(guar))) => Err(Answer::Err(guar)),
+ (Err(Err::Unknown(guar)), _) => Err(Answer::Err(guar)),
+ (_, Err(Err::Unknown(guar))) => Err(Answer::Err(guar)),
  (Err(Err::Unspecified), _) => Err(Answer::No(Reason::SrcIsUnspecified)),
  (_, Err(Err::Unspecified)) => Err(Answer::No(Reason::DstIsUnspecified)),
  (Ok(src), Ok(dst)) => Ok((src, dst)),