stop using ParamEnv::reveal while handling MIR

Author: lcnr

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -589,7 +589,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
 // Typeck only does a "non-const" check since it operates on HIR and cannot distinguish
 // which path expressions are getting called on and which path expressions are only used
 // as function pointers. This is required for correctness.
-let infcx = tcx.infer_ctxt().build(body.phase.typing_mode());
+let infcx = tcx.infer_ctxt().build(body.typing_mode(tcx));
 let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
 
 let predicates = tcx.predicates_of(callee).instantiate(tcx, fn_args);

compiler/rustc_const_eval/src/check_consts/ops.rs

@@ -116,7 +116,7 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
 let obligation =
 Obligation::new(tcx,ObligationCause::dummy(), param_env, trait_ref);
 
-let infcx = tcx.infer_ctxt().build(body.phase.typing_mode());
+let infcx = tcx.infer_ctxt().build(body.typing_mode(tcx));
 letmut selcx = SelectionContext::new(&infcx);
 let implsrc = selcx.select(&obligation);
 

compiler/rustc_const_eval/src/interpret/eval_context.rs

@@ -3,7 +3,7 @@ use rustc_errors::DiagCtxtHandle;
 use rustc_hir::def_id::DefId;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_infer::infer::at::ToTrace;
-use rustc_infer::traits::ObligationCause;
+use rustc_infer::traits::{ObligationCause,Reveal};
 use rustc_middle::mir::interpret::{ErrorHandled,InvalidMetaKind,ReportedErrorInfo};
 use rustc_middle::query::TyCtxtAt;
 use rustc_middle::ty::layout::{
@@ -116,6 +116,7 @@ impl<'tcx, M: Machine<'tcx>> FnAbiOfHelpers<'tcx> for InterpCx<'tcx, M> {
 /// This test should be symmetric, as it is primarily about layout compatibility.
 pub(super)fnmir_assign_valid_types<'tcx>(
 tcx:TyCtxt<'tcx>,
+typing_mode:TypingMode<'tcx>,
 param_env:ParamEnv<'tcx>,
 src:TyAndLayout<'tcx>,
 dest:TyAndLayout<'tcx>,
@@ -124,7 +125,7 @@ pub(super) fn mir_assign_valid_types<'tcx>(
 // all normal lifetimes are erased, higher-ranked types with their
 // late-bound lifetimes are still around and can lead to type
 // differences.
-if util::relate_types(tcx, param_env,Variance::Covariant, src.ty, dest.ty){
+if util::relate_types(tcx,typing_mode,param_env,Variance::Covariant, src.ty, dest.ty){
 // Make sure the layout is equal, too -- just to be safe. Miri really
 // needs layout equality. For performance reason we skip this check when
 // the types are equal. Equal types *can* have different layouts when
@@ -144,6 +145,7 @@ pub(super) fn mir_assign_valid_types<'tcx>(
 #[cfg_attr(not(debug_assertions), inline(always))]
 pub(super)fnfrom_known_layout<'tcx>(
 tcx:TyCtxtAt<'tcx>,
+typing_mode:TypingMode<'tcx>,
 param_env:ParamEnv<'tcx>,
 known_layout:Option<TyAndLayout<'tcx>>,
 compute:implFnOnce() -> InterpResult<'tcx,TyAndLayout<'tcx>>,
@@ -153,7 +155,13 @@ pub(super) fn from_known_layout<'tcx>(
 Some(known_layout) => {
 ifcfg!(debug_assertions){
 let check_layout = compute()?;
-if !mir_assign_valid_types(tcx.tcx, param_env, check_layout, known_layout){
+if !mir_assign_valid_types(
+ tcx.tcx,
+ typing_mode,
+ param_env,
+ check_layout,
+ known_layout,
+){
 span_bug!(
  tcx.span,
 "expected type differs from actual type.\nexpected: {}\nactual: {}",
@@ -203,6 +211,11 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 }
 }
 
+pubfntyping_mode(&self) -> TypingMode<'tcx>{
+debug_assert_eq!(self.param_env.reveal(),Reveal::All);
+TypingMode::PostAnalysis
+}
+
 /// Returns the span of the currently executed statement/terminator.
 /// This is the span typically used for error reporting.
 #[inline(always)]
@@ -327,7 +340,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 returntrue;
 }
 // Slow path: spin up an inference context to check if these traits are sufficiently equal.
-let infcx = self.tcx.infer_ctxt().build(TypingMode::from_param_env(self.param_env));
+let infcx = self.tcx.infer_ctxt().build(self.typing_mode());
 let ocx = ObligationCtxt::new(&infcx);
 let cause = ObligationCause::dummy_with_span(self.cur_span());
 // equate the two trait refs after normalization

compiler/rustc_const_eval/src/interpret/operand.rs

@@ -773,6 +773,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 )?;
 if !mir_assign_valid_types(
 *self.tcx,
+self.typing_mode(),
 self.param_env,
 self.layout_of(normalized_place_ty)?,
  op.layout,
@@ -832,7 +833,9 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 })
 };
 let layout =
-from_known_layout(self.tcx,self.param_env, layout, || self.layout_of(ty).into())?;
+from_known_layout(self.tcx,self.typing_mode(),self.param_env, layout, || {
+self.layout_of(ty).into()
+})?;
 let imm = match val_val {
  mir::ConstValue::Indirect{ alloc_id, offset } => {
 // This is const data, no mutation allowed.

compiler/rustc_const_eval/src/interpret/place.rs

@@ -540,6 +540,7 @@ where
 )?;
 if !mir_assign_valid_types(
 *self.tcx,
+self.typing_mode(),
 self.param_env,
 self.layout_of(normalized_place_ty)?,
  place.layout,
@@ -870,8 +871,13 @@ where
 ) -> InterpResult<'tcx>{
 // We do NOT compare the types for equality, because well-typed code can
 // actually "transmute" `&mut T` to `&T` in an assignment without a cast.
-let layout_compat =
-mir_assign_valid_types(*self.tcx,self.param_env, src.layout(), dest.layout());
+let layout_compat = mir_assign_valid_types(
+*self.tcx,
+self.typing_mode(),
+self.param_env,
+ src.layout(),
+ dest.layout(),
+);
 if !allow_transmute && !layout_compat {
 span_bug!(
 self.cur_span(),

compiler/rustc_const_eval/src/interpret/stack.rs

@@ -596,12 +596,13 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 returninterp_ok(layout);
 }
 
-let layout = from_known_layout(self.tcx,self.param_env, layout, || {
-let local_ty = frame.body.local_decls[local].ty;
-let local_ty =
-self.instantiate_from_frame_and_normalize_erasing_regions(frame, local_ty)?;
-self.layout_of(local_ty).into()
-})?;
+let layout =
+from_known_layout(self.tcx,self.typing_mode(),self.param_env, layout, || {
+let local_ty = frame.body.local_decls[local].ty;
+let local_ty =
+self.instantiate_from_frame_and_normalize_erasing_regions(frame, local_ty)?;
+self.layout_of(local_ty).into()
+})?;
 
 // Layouts of locals are requested a lot, so we cache them.
  state.layout.set(Some(layout));

compiler/rustc_const_eval/src/util/compare_types.rs

@@ -8,24 +8,15 @@ use rustc_middle::traits::ObligationCause;
 use rustc_middle::ty::{ParamEnv,Ty,TyCtxt,TypingMode,Variance};
 use rustc_trait_selection::traits::ObligationCtxt;
 
-/// Returns whether the two types are equal up to subtyping.
-///
-/// This is used in case we don't know the expected subtyping direction
-/// and still want to check whether anything is broken.
-pubfnis_equal_up_to_subtyping<'tcx>(
+/// Returns whether `src` is a subtype of `dest`, i.e. `src <: dest`.
+pubfnsub_types<'tcx>(
 tcx:TyCtxt<'tcx>,
+typing_mode:TypingMode<'tcx>,
 param_env:ParamEnv<'tcx>,
 src:Ty<'tcx>,
 dest:Ty<'tcx>,
 ) -> bool{
-// Fast path.
-if src == dest {
-returntrue;
-}
-
-// Check for subtyping in either direction.
-relate_types(tcx, param_env,Variance::Covariant, src, dest)
- || relate_types(tcx, param_env,Variance::Covariant, dest, src)
+relate_types(tcx, typing_mode, param_env,Variance::Covariant, src, dest)
 }
 
 /// Returns whether `src` is a subtype of `dest`, i.e. `src <: dest`.
@@ -35,6 +26,7 @@ pub fn is_equal_up_to_subtyping<'tcx>(
 /// because we want to check for type equality.
 pubfnrelate_types<'tcx>(
 tcx:TyCtxt<'tcx>,
+typing_mode:TypingMode<'tcx>,
 param_env:ParamEnv<'tcx>,
 variance:Variance,
 src:Ty<'tcx>,
@@ -45,8 +37,7 @@ pub fn relate_types<'tcx>(
 }
 
 letmut builder = tcx.infer_ctxt().ignoring_regions();
-// FIXME(#132279): This should eventually use the already defined hidden types.
-let infcx = builder.build(TypingMode::from_param_env(param_env));
+let infcx = builder.build(typing_mode);
 let ocx = ObligationCtxt::new(&infcx);
 let cause = ObligationCause::dummy();
 let src = ocx.normalize(&cause, param_env, src);

compiler/rustc_const_eval/src/util/mod.rs

@@ -8,7 +8,7 @@ mod type_name;
 
 pubuseself::alignment::{is_disaligned, is_within_packed};
 pubuseself::check_validity_requirement::check_validity_requirement;
-pubuseself::compare_types::{is_equal_up_to_subtyping, relate_types};
+pubuseself::compare_types::{relate_types, sub_types};
 pubuseself::type_name::type_name;
 
 /// Classify whether an operator is "left-homogeneous", i.e., the LHS has the

compiler/rustc_middle/src/mir/mod.rs

@@ -39,7 +39,7 @@ use crate::ty::fold::{FallibleTypeFolder, TypeFoldable};
 usecrate::ty::print::{FmtPrinter,Printer, pretty_print_const, with_no_trimmed_paths};
 usecrate::ty::visit::TypeVisitableExt;
 usecrate::ty::{
-self,AdtDef,GenericArg,GenericArgsRef,Instance,InstanceKind,List,Ty,TyCtxt,
+self,AdtDef,GenericArg,GenericArgsRef,Instance,InstanceKind,List,Ty,TyCtxt,TypingMode,
 UserTypeAnnotationIndex,
 };
 
@@ -452,6 +452,15 @@ impl<'tcx> Body<'tcx> {
 self.basic_blocks.as_mut()
 }
 
+pubfntyping_mode(&self,_tcx:TyCtxt<'tcx>) -> TypingMode<'tcx>{
+matchself.phase{
+// FIXME(#132279): the MIR is quite clearly inside of a body, so we
+// should instead reveal opaques defined by that body here.
+MirPhase::Built | MirPhase::Analysis(_) => TypingMode::non_body_analysis(),
+MirPhase::Runtime(_) => TypingMode::PostAnalysis,
+}
+}
+
 #[inline]
 pubfnlocal_kind(&self,local:Local) -> LocalKind{
 let index = local.as_usize();

compiler/rustc_middle/src/mir/syntax.rs

@@ -20,9 +20,7 @@ use smallvec::SmallVec;
 usesuper::{BasicBlock,Const,Local,UserTypeProjection};
 usecrate::mir::coverage::CoverageKind;
 usecrate::ty::adjustment::PointerCoercion;
-usecrate::ty::{
-self,GenericArgsRef,List,Region,Ty,TyCtxt,TypingMode,UserTypeAnnotationIndex,
-};
+usecrate::ty::{self,GenericArgsRef,List,Region,Ty,TyCtxt,UserTypeAnnotationIndex};
 
 /// Represents the "flavors" of MIR.
 ///
@@ -103,20 +101,10 @@ impl MirPhase {
 }
 }
 
-pubfntyping_mode<'tcx>(&self) -> TypingMode<'tcx>{
-matchself{
-// FIXME(#132279): the MIR is quite clearly inside of a body, so we
-// should instead reveal opaques defined by that body here.
-MirPhase::Built | MirPhase::Analysis(_) => TypingMode::non_body_analysis(),
-MirPhase::Runtime(_) => TypingMode::PostAnalysis,
-}
-}
-
 pubfnparam_env<'tcx>(&self,tcx:TyCtxt<'tcx>,body_def_id:DefId) -> ty::ParamEnv<'tcx>{
-matchself.typing_mode(){
-TypingMode::Coherence => unreachable!(),
-TypingMode::Analysis{defining_opaque_types: _ } => tcx.param_env(body_def_id),
-TypingMode::PostAnalysis => tcx.param_env_reveal_all_normalized(body_def_id),
+matchself{
+MirPhase::Built | MirPhase::Analysis(_) => tcx.param_env(body_def_id),
+MirPhase::Runtime(_) => tcx.param_env_reveal_all_normalized(body_def_id),
 }
 }
 }