Rollup merge of #127570 - lcnr:normalize-cool, r=compiler-errors

 small normalization improvement

r? `@compiler-errors`

Author: matthiaskrgr

compiler/rustc_trait_selection/src/traits/normalize.rs

@@ -109,16 +109,13 @@ pub(super) fn needs_normalization<'tcx, T: TypeVisitable<TyCtxt<'tcx>>>(
     value: &T,
     reveal: Reveal,
 ) -> bool {
-    // This mirrors `ty::TypeFlags::HAS_ALIASES` except that we take `Reveal` into account.
-
-    let mut flags = ty::TypeFlags::HAS_TY_PROJECTION
-        | ty::TypeFlags::HAS_TY_WEAK
-        | ty::TypeFlags::HAS_TY_INHERENT
-        | ty::TypeFlags::HAS_CT_PROJECTION;
+    let mut flags = ty::TypeFlags::HAS_ALIAS;
 
+    // Opaques are treated as rigid with `Reveal::UserFacing`,
+    // so we can ignore those.
     match reveal {
-        Reveal::UserFacing => {}
-        Reveal::All => flags |= ty::TypeFlags::HAS_TY_OPAQUE,
+        Reveal::UserFacing => flags.remove(ty::TypeFlags::HAS_TY_OPAQUE),
+        Reveal::All => {}
     }
 
     value.has_type_flags(flags)

compiler/rustc_type_ir/src/flags.rs

@@ -14,7 +14,7 @@ bitflags::bitflags! {
         /// Does this have `ConstKind::Param`?
         const HAS_CT_PARAM                = 1 << 2;
 
-        const HAS_PARAM                 = TypeFlags::HAS_TY_PARAM.bits()
+        const HAS_PARAM                   = TypeFlags::HAS_TY_PARAM.bits()
                                           | TypeFlags::HAS_RE_PARAM.bits()
                                           | TypeFlags::HAS_CT_PARAM.bits();
 
@@ -27,7 +27,7 @@ bitflags::bitflags! {
 
         /// Does this have inference variables? Used to determine whether
         /// inference is required.
-        const HAS_INFER                 = TypeFlags::HAS_TY_INFER.bits()
+        const HAS_INFER                   = TypeFlags::HAS_TY_INFER.bits()
                                           | TypeFlags::HAS_RE_INFER.bits()
                                           | TypeFlags::HAS_CT_INFER.bits();
 
@@ -39,7 +39,7 @@ bitflags::bitflags! {
         const HAS_CT_PLACEHOLDER          = 1 << 8;
 
         /// Does this have placeholders?
-        const HAS_PLACEHOLDER           = TypeFlags::HAS_TY_PLACEHOLDER.bits()
+        const HAS_PLACEHOLDER             = TypeFlags::HAS_TY_PLACEHOLDER.bits()
                                           | TypeFlags::HAS_RE_PLACEHOLDER.bits()
                                           | TypeFlags::HAS_CT_PLACEHOLDER.bits();
 
@@ -81,7 +81,7 @@ bitflags::bitflags! {
         /// Does this have `Alias` or `ConstKind::Unevaluated`?
         ///
         /// Rephrased, could this term be normalized further?
-        const HAS_ALIASES              = TypeFlags::HAS_TY_PROJECTION.bits()
+        const HAS_ALIAS                   = TypeFlags::HAS_TY_PROJECTION.bits()
                                           | TypeFlags::HAS_TY_WEAK.bits()
                                           | TypeFlags::HAS_TY_OPAQUE.bits()
                                           | TypeFlags::HAS_TY_INHERENT.bits()

compiler/rustc_type_ir/src/visit.rs

@@ -230,7 +230,7 @@ pub trait TypeVisitableExt<I: Interner>: TypeVisitable<I> {
     }
 
     fn has_aliases(&self) -> bool {
-        self.has_type_flags(TypeFlags::HAS_ALIASES)
+        self.has_type_flags(TypeFlags::HAS_ALIAS)
     }
 
     fn has_inherent_projections(&self) -> bool {