normalization folders, yeet ParamEnv::reveal

Author: lcnr

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -411,7 +411,7 @@ pub fn normalize_param_env_or_error<'tcx>(
 debug!("normalize_param_env_or_error: elaborated-predicates={:?}", predicates);
 
 let elaborated_env = ty::ParamEnv::new(tcx.mk_clauses(&predicates), unnormalized_env.reveal());
-if !normalize::needs_normalization(&elaborated_env, unnormalized_env.reveal()){
+if !elaborated_env.has_aliases(){
 return elaborated_env;
 }
 

compiler/rustc_trait_selection/src/traits/normalize.rs

@@ -1,15 +1,16 @@
 //! Deeply normalize types using the old trait solver.
 
 use rustc_data_structures::stack::ensure_sufficient_stack;
-use rustc_infer::infer::InferOk;
 use rustc_infer::infer::at::At;
+use rustc_infer::infer::{InferCtxt,InferOk};
 use rustc_infer::traits::{
 FromSolverError,Normalized,Obligation,PredicateObligations,TraitEngine,
 };
 use rustc_macros::extension;
-use rustc_middle::traits::{ObligationCause,ObligationCauseCode,Reveal};
+use rustc_middle::traits::{ObligationCause,ObligationCauseCode};
 use rustc_middle::ty::{
 self,Ty,TyCtxt,TypeFoldable,TypeFolder,TypeSuperFoldable,TypeVisitable,TypeVisitableExt,
+TypingMode,
 };
 use tracing::{debug, instrument};
 
@@ -109,16 +110,19 @@ where
 }
 
 pub(super)fnneeds_normalization<'tcx,T:TypeVisitable<TyCtxt<'tcx>>>(
+infcx:&InferCtxt<'tcx>,
+param_env_for_debug_assertion: ty::ParamEnv<'tcx>,
 value:&T,
-reveal:Reveal,
 ) -> bool{
 letmut flags = ty::TypeFlags::HAS_ALIAS;
 
 // Opaques are treated as rigid with `Reveal::UserFacing`,
 // so we can ignore those.
-match reveal {
-Reveal::UserFacing => flags.remove(ty::TypeFlags::HAS_TY_OPAQUE),
-Reveal::All => {}
+match infcx.typing_mode(param_env_for_debug_assertion){
+TypingMode::Coherence | TypingMode::Analysis{defining_opaque_types: _ } => {
+ flags.remove(ty::TypeFlags::HAS_TY_OPAQUE)
+}
+TypingMode::PostAnalysis => {}
 }
 
  value.has_type_flags(flags)
@@ -154,7 +158,7 @@ impl<'a, 'b, 'tcx> AssocTypeNormalizer<'a, 'b, 'tcx> {
 "Normalizing {value:?} without wrapping in a `Binder`"
 );
 
-if !needs_normalization(&value,self.param_env.reveal()){
+if !needs_normalization(self.selcx.infcx,self.param_env,&value){
  value
 }else{
  value.fold_with(self)
@@ -178,7 +182,7 @@ impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx
 }
 
 fnfold_ty(&mutself,ty:Ty<'tcx>) -> Ty<'tcx>{
-if !needs_normalization(&ty,self.param_env.reveal()){
+if !needs_normalization(self.selcx.infcx,self.param_env,&ty){
 return ty;
 }
 
@@ -213,10 +217,11 @@ impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx
 match kind {
  ty::Opaque => {
 // Only normalize `impl Trait` outside of type inference, usually in codegen.
-matchself.param_env.reveal(){
-Reveal::UserFacing => ty.super_fold_with(self),
-
-Reveal::All => {
+matchself.selcx.infcx.typing_mode(self.param_env){
+TypingMode::Coherence | TypingMode::Analysis{defining_opaque_types: _ } => {
+ ty.super_fold_with(self)
+}
+TypingMode::PostAnalysis => {
 let recursion_limit = self.cx().recursion_limit();
 if !recursion_limit.value_within_limit(self.depth){
 self.selcx.infcx.err_ctxt().report_overflow_error(
@@ -403,7 +408,7 @@ impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx
 fnfold_const(&mutself,constant: ty::Const<'tcx>) -> ty::Const<'tcx>{
 let tcx = self.selcx.tcx();
 if tcx.features().generic_const_exprs()
- || !needs_normalization(&constant,self.param_env.reveal())
+ || !needs_normalization(self.selcx.infcx,self.param_env,&constant)
 {
  constant
 }else{
@@ -420,7 +425,7 @@ impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx
 
 #[inline]
 fnfold_predicate(&mutself,p: ty::Predicate<'tcx>) -> ty::Predicate<'tcx>{
-if p.allow_normalization() && needs_normalization(&p,self.param_env.reveal()){
+if p.allow_normalization() && needs_normalization(self.selcx.infcx,self.param_env,&p){
  p.super_fold_with(self)
 }else{
  p

compiler/rustc_trait_selection/src/traits/query/normalize.rs

@@ -9,7 +9,7 @@ use rustc_macros::extension;
 pubuse rustc_middle::traits::query::NormalizationResult;
 use rustc_middle::ty::fold::{FallibleTypeFolder,TypeFoldable,TypeSuperFoldable};
 use rustc_middle::ty::visit::{TypeSuperVisitable,TypeVisitable,TypeVisitableExt};
-use rustc_middle::ty::{self,Ty,TyCtxt,TypeVisitor};
+use rustc_middle::ty::{self,Ty,TyCtxt,TypeVisitor,TypingMode};
 use rustc_span::DUMMY_SP;
 use tracing::{debug, info, instrument};
 
@@ -21,7 +21,7 @@ use crate::infer::canonical::OriginalQueryValues;
 usecrate::infer::{InferCtxt,InferOk};
 usecrate::traits::normalize::needs_normalization;
 usecrate::traits::{
-BoundVarReplacer,Normalized,ObligationCause,PlaceholderReplacer,Reveal,ScrubbedTraitError,
+BoundVarReplacer,Normalized,ObligationCause,PlaceholderReplacer,ScrubbedTraitError,
 };
 
 #[extension(pubtraitQueryNormalizeExt<'tcx>)]
@@ -89,7 +89,7 @@ impl<'a, 'tcx> At<'a, 'tcx> {
 }
 }
 
-if !needs_normalization(&value,self.param_env.reveal()){
+if !needs_normalization(self.infcx,self.param_env,&value){
 returnOk(Normalized{ value,obligations:PredicateObligations::new()});
 }
 
@@ -191,7 +191,7 @@ impl<'a, 'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for QueryNormalizer<'a, 'tcx> {
 
 #[instrument(level = "debug", skip(self))]
 fntry_fold_ty(&mutself,ty:Ty<'tcx>) -> Result<Ty<'tcx>,Self::Error>{
-if !needs_normalization(&ty,self.param_env.reveal()){
+if !needs_normalization(self.infcx,self.param_env,&ty){
 returnOk(ty);
 }
 
@@ -215,10 +215,12 @@ impl<'a, 'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for QueryNormalizer<'a, 'tcx> {
 let res = match kind {
  ty::Opaque => {
 // Only normalize `impl Trait` outside of type inference, usually in codegen.
-matchself.param_env.reveal(){
-Reveal::UserFacing => ty.try_super_fold_with(self)?,
+matchself.infcx.typing_mode(self.param_env){
+TypingMode::Coherence | TypingMode::Analysis{defining_opaque_types: _ } => {
+ ty.try_super_fold_with(self)?
+}
 
-Reveal::All => {
+TypingMode::PostAnalysis => {
 let args = data.args.try_fold_with(self)?;
 let recursion_limit = self.cx().recursion_limit();
 
@@ -332,7 +334,7 @@ impl<'a, 'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for QueryNormalizer<'a, 'tcx> {
 &mutself,
 constant: ty::Const<'tcx>,
 ) -> Result<ty::Const<'tcx>,Self::Error>{
-if !needs_normalization(&constant,self.param_env.reveal()){
+if !needs_normalization(self.infcx,self.param_env,&constant){
 returnOk(constant);
 }
 
@@ -351,7 +353,7 @@ impl<'a, 'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for QueryNormalizer<'a, 'tcx> {
 &mutself,
 p: ty::Predicate<'tcx>,
 ) -> Result<ty::Predicate<'tcx>,Self::Error>{
-if p.allow_normalization() && needs_normalization(&p,self.param_env.reveal()){
+if p.allow_normalization() && needs_normalization(self.infcx,self.param_env,&p){
  p.try_super_fold_with(self)
 }else{
 Ok(p)