Make needs_normalization into a TypeFoldable method

Author: compiler-errors

compiler/rustc_middle/src/ty/normalize_erasing_regions.rs

@@ -52,7 +52,7 @@ impl<'tcx> TyCtxt<'tcx> {
         let value = self.erase_regions(value);
         debug!(?value);
 
-        if !value.has_projections() {
+        if !value.needs_normalization(param_env.reveal()) {
             value
         } else {
             value.fold_with(&mut NormalizeAfterErasingRegionsFolder { tcx: self, param_env })
@@ -84,7 +84,7 @@ impl<'tcx> TyCtxt<'tcx> {
         let value = self.erase_regions(value);
         debug!(?value);
 
-        if !value.has_projections() {
+        if !value.needs_normalization(param_env.reveal()) {
             Ok(value)
         } else {
             let mut folder = TryNormalizeAfterErasingRegionsFolder::new(self, param_env);

compiler/rustc_middle/src/ty/visit.rs

@@ -160,6 +160,19 @@ pub trait TypeVisitable<'tcx>: fmt::Debug + Clone {
     fn still_further_specializable(&self) -> bool {
         self.has_type_flags(TypeFlags::STILL_FURTHER_SPECIALIZABLE)
     }
+
+    fn needs_normalization(&self, reveal: ty::Reveal) -> bool {
+        match reveal {
+            ty::Reveal::UserFacing => {
+                self.has_type_flags(TypeFlags::HAS_TY_PROJECTION | TypeFlags::HAS_CT_PROJECTION)
+            }
+            ty::Reveal::All => self.has_type_flags(
+                TypeFlags::HAS_TY_PROJECTION
+                    | TypeFlags::HAS_TY_OPAQUE
+                    | TypeFlags::HAS_CT_PROJECTION,
+            ),
+        }
+    }
 }
 
 pub trait TypeSuperVisitable<'tcx>: TypeVisitable<'tcx> {
@@ -537,7 +550,7 @@ struct FoundFlags;
 
 // FIXME: Optimize for checking for infer flags
 struct HasTypeFlagsVisitor {
-    flags: ty::TypeFlags,
+    flags: TypeFlags,
 }
 
 impl std::fmt::Debug for HasTypeFlagsVisitor {

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -285,7 +285,7 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
 
         let infcx = self.selcx.infcx();
 
-        if obligation.predicate.has_projections() {
+        if obligation.predicate.needs_normalization(obligation.param_env.reveal()) {
             let mut obligations = Vec::new();
             let predicate = crate::traits::project::try_normalize_with_depth_to(
                 &mut self.selcx,

compiler/rustc_trait_selection/src/traits/project.rs

@@ -381,18 +381,6 @@ where
     result
 }
 
-pub(crate) fn needs_normalization<'tcx, T: TypeVisitable<'tcx>>(value: &T, reveal: Reveal) -> bool {
-    match reveal {
-        Reveal::UserFacing => value
-            .has_type_flags(ty::TypeFlags::HAS_TY_PROJECTION | ty::TypeFlags::HAS_CT_PROJECTION),
-        Reveal::All => value.has_type_flags(
-            ty::TypeFlags::HAS_TY_PROJECTION
-                | ty::TypeFlags::HAS_TY_OPAQUE
-                | ty::TypeFlags::HAS_CT_PROJECTION,
-        ),
-    }
-}
-
 struct AssocTypeNormalizer<'a, 'b, 'tcx> {
     selcx: &'a mut SelectionContext<'b, 'tcx>,
     param_env: ty::ParamEnv<'tcx>,
@@ -453,7 +441,7 @@ impl<'a, 'b, 'tcx> AssocTypeNormalizer<'a, 'b, 'tcx> {
             value
         );
 
-        if !needs_normalization(&value, self.param_env.reveal()) {
+        if !value.needs_normalization(self.param_env.reveal()) {
             value
         } else {
             value.fold_with(self)
@@ -477,7 +465,7 @@ impl<'a, 'b, 'tcx> TypeFolder<'tcx> for AssocTypeNormalizer<'a, 'b, 'tcx> {
     }
 
     fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
-        if !needs_normalization(&ty, self.param_env.reveal()) {
+        if !ty.needs_normalization(self.param_env.reveal()) {
             return ty;
         }
 
@@ -663,7 +651,7 @@ impl<'a, 'b, 'tcx> TypeFolder<'tcx> 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() && p.needs_normalization(self.param_env.reveal()) {
             p.super_fold_with(self)
         } else {
             p
@@ -1124,7 +1112,7 @@ fn opt_normalize_projection_type<'a, 'b, 'tcx>(
 
             let projected_term = selcx.infcx().resolve_vars_if_possible(projected_term);
 
-            let mut result = if projected_term.has_projections() {
+            let mut result = if projected_term.needs_normalization(param_env.reveal()) {
                 let mut normalizer = AssocTypeNormalizer::new(
                     selcx,
                     param_env,

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

@@ -6,7 +6,7 @@ use crate::infer::at::At;
 use crate::infer::canonical::OriginalQueryValues;
 use crate::infer::{InferCtxt, InferOk};
 use crate::traits::error_reporting::TypeErrCtxtExt;
-use crate::traits::project::{needs_normalization, BoundVarReplacer, PlaceholderReplacer};
+use crate::traits::project::{BoundVarReplacer, PlaceholderReplacer};
 use crate::traits::{Obligation, ObligationCause, PredicateObligation, Reveal};
 use rustc_data_structures::sso::SsoHashMap;
 use rustc_data_structures::stack::ensure_sufficient_stack;
@@ -54,7 +54,7 @@ impl<'cx, 'tcx> AtExt<'tcx> for At<'cx, 'tcx> {
             self.param_env,
             self.cause,
         );
-        if !needs_normalization(&value, self.param_env.reveal()) {
+        if !value.needs_normalization(self.param_env.reveal()) {
             return Ok(Normalized { value, obligations: vec![] });
         }
 
@@ -183,7 +183,7 @@ impl<'cx, 'tcx> FallibleTypeFolder<'tcx> for QueryNormalizer<'cx, 'tcx> {
 
     #[instrument(level = "debug", skip(self))]
     fn try_fold_ty(&mut self, ty: Ty<'tcx>) -> Result<Ty<'tcx>, Self::Error> {
-        if !needs_normalization(&ty, self.param_env.reveal()) {
+        if !ty.needs_normalization(self.param_env.reveal()) {
             return Ok(ty);
         }
 
@@ -375,7 +375,7 @@ impl<'cx, 'tcx> FallibleTypeFolder<'tcx> for QueryNormalizer<'cx, 'tcx> {
         &mut self,
         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() && p.needs_normalization(self.param_env.reveal()) {
             p.try_super_fold_with(self)
         } else {
             Ok(p)

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

@@ -13,7 +13,11 @@ where
     type QueryResponse = T;
 
     fn try_fast_path(_tcx: TyCtxt<'tcx>, key: &ParamEnvAnd<'tcx, Self>) -> Option<T> {
-        if !key.value.value.has_projections() { Some(key.value.value) } else { None }
+        if !key.value.value.needs_normalization(key.param_env.reveal()) {
+            Some(key.value.value)
+        } else {
+            None
+        }
     }
 
     fn perform_query(

compiler/rustc_ty_utils/src/layout.rs

@@ -431,9 +431,9 @@ fn layout_of_uncached<'tcx>(
 
         // Arrays and slices.
         ty::Array(element, mut count) => {
-            if count.has_projections() {
+            if count.needs_normalization(param_env.reveal()) {
                 count = tcx.normalize_erasing_regions(param_env, count);
-                if count.has_projections() {
+                if count.needs_normalization(param_env.reveal()) {
                     return Err(LayoutError::Unknown(ty));
                 }
             }