From dc750665ae84cdedfbae4d5b3c69f4d20faa14dc Mon Sep 17 00:00:00 2001 From: lcnr Date: Thu, 31 Oct 2024 13:05:27 +0100 Subject: [PATCH] normalization folders, yeet `ParamEnv::reveal` --- .../rustc_trait_selection/src/traits/mod.rs | 2 +- .../src/traits/normalize.rs | 33 +++++++++++-------- .../src/traits/query/normalize.rs | 20 ++++++----- 3 files changed, 31 insertions(+), 24 deletions(-) diff --git a/compiler/rustc_trait_selection/src/traits/mod.rs b/compiler/rustc_trait_selection/src/traits/mod.rs index 1c84f2171bc..436c0fabd29 100644 --- a/compiler/rustc_trait_selection/src/traits/mod.rs +++ b/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; } diff --git a/compiler/rustc_trait_selection/src/traits/normalize.rs b/compiler/rustc_trait_selection/src/traits/normalize.rs index 12e00ec79ac..954dfe93387 100644 --- a/compiler/rustc_trait_selection/src/traits/normalize.rs +++ b/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) fn needs_normalization<'tcx, T: TypeVisitable>>( + infcx: &InferCtxt<'tcx>, + param_env_for_debug_assertion: ty::ParamEnv<'tcx>, value: &T, - reveal: Reveal, ) -> bool { let mut 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> for AssocTypeNormalizer<'a, 'b, 'tcx } fn fold_ty(&mut self, 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> for AssocTypeNormalizer<'a, 'b, 'tcx match kind { ty::Opaque => { // Only normalize `impl Trait` outside of type inference, usually in codegen. - match self.param_env.reveal() { - Reveal::UserFacing => ty.super_fold_with(self), - - Reveal::All => { + match self.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> for AssocTypeNormalizer<'a, 'b, 'tcx fn fold_const(&mut self, 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> for AssocTypeNormalizer<'a, 'b, 'tcx #[inline] fn fold_predicate(&mut self, 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 diff --git a/compiler/rustc_trait_selection/src/traits/query/normalize.rs b/compiler/rustc_trait_selection/src/traits/query/normalize.rs index 01e6516302c..a8d701a750d 100644 --- a/compiler/rustc_trait_selection/src/traits/query/normalize.rs +++ b/compiler/rustc_trait_selection/src/traits/query/normalize.rs @@ -9,7 +9,7 @@ use rustc_macros::extension; pub use 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; use crate::infer::{InferCtxt, InferOk}; use crate::traits::normalize::needs_normalization; use crate::traits::{ - BoundVarReplacer, Normalized, ObligationCause, PlaceholderReplacer, Reveal, ScrubbedTraitError, + BoundVarReplacer, Normalized, ObligationCause, PlaceholderReplacer, ScrubbedTraitError, }; #[extension(pub trait QueryNormalizeExt<'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) { return Ok(Normalized { value, obligations: PredicateObligations::new() }); } @@ -191,7 +191,7 @@ impl<'a, 'tcx> FallibleTypeFolder> for QueryNormalizer<'a, 'tcx> { #[instrument(level = "debug", skip(self))] fn try_fold_ty(&mut self, ty: Ty<'tcx>) -> Result, Self::Error> { - if !needs_normalization(&ty, self.param_env.reveal()) { + if !needs_normalization(self.infcx, self.param_env, &ty) { return Ok(ty); } @@ -215,10 +215,12 @@ impl<'a, 'tcx> FallibleTypeFolder> for QueryNormalizer<'a, 'tcx> { let res = match kind { ty::Opaque => { // Only normalize `impl Trait` outside of type inference, usually in codegen. - match self.param_env.reveal() { - Reveal::UserFacing => ty.try_super_fold_with(self)?, + match self.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> for QueryNormalizer<'a, 'tcx> { &mut self, constant: ty::Const<'tcx>, ) -> Result, Self::Error> { - if !needs_normalization(&constant, self.param_env.reveal()) { + if !needs_normalization(self.infcx, self.param_env, &constant) { return Ok(constant); } @@ -351,7 +353,7 @@ impl<'a, 'tcx> FallibleTypeFolder> for QueryNormalizer<'a, 'tcx> { &mut self, p: ty::Predicate<'tcx>, ) -> Result, 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)