hir_analysis: specialisation w/ host effect preds

There are some uses of `min_specialization` in the standard library which
now see `HostEffectPredicate` - this shouldn't prevent specialization
for the sizedness marker traits that are now const.

Author: davidtwco

compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs

@@ -436,9 +436,10 @@ fn check_specialization_on<'tcx>(
         // Global predicates are either always true or always false, so we
         // are fine to specialize on.
         _ if clause.is_global() => Ok(()),
-        // We allow specializing on explicitly marked traits with no associated
+        // We allow specializing on explicitly marked traits (and host effects) with no associated
         // items.
-        ty::ClauseKind::Trait(ty::TraitPredicate { trait_ref, polarity: _ }) => {
+        ty::ClauseKind::Trait(ty::TraitPredicate { trait_ref, polarity: _ })
+        | ty::ClauseKind::HostEffect(ty::HostEffectPredicate { trait_ref, constness: _ }) => {
             if matches!(
                 trait_specialization_kind(tcx, clause),
                 Some(TraitSpecializationKind::Marker)
@@ -487,15 +488,15 @@ fn trait_specialization_kind<'tcx>(
     clause: ty::Clause<'tcx>,
 ) -> Option<TraitSpecializationKind> {
     match clause.kind().skip_binder() {
-        ty::ClauseKind::Trait(ty::TraitPredicate { trait_ref, polarity: _ }) => {
+        ty::ClauseKind::Trait(ty::TraitPredicate { trait_ref, polarity: _ })
+        | ty::ClauseKind::HostEffect(ty::HostEffectPredicate { trait_ref, constness: _ }) => {
             Some(tcx.trait_def(trait_ref.def_id).specialization_kind)
         }
         ty::ClauseKind::RegionOutlives(_)
         | ty::ClauseKind::TypeOutlives(_)
         | ty::ClauseKind::Projection(_)
         | ty::ClauseKind::ConstArgHasType(..)
         | ty::ClauseKind::WellFormed(_)
-        | ty::ClauseKind::ConstEvaluatable(..)
-        | ty::ClauseKind::HostEffect(..) => None,
+        | ty::ClauseKind::ConstEvaluatable(..) => None,
     }
 }

tests/ui/sized-hierarchy/specialisation.rs

@@ -0,0 +1,32 @@
+//@ check-pass
+//@ compile-flags: --crate-type=lib
+#![no_std]
+#![allow(internal_features)]
+#![feature(rustc_attrs, min_specialization)]
+
+// Confirm that specialisation w/ sizedness host effect predicates works.
+
+pub trait Iterator {
+    type Item;
+}
+
+#[rustc_unsafe_specialization_marker]
+pub trait MoreSpecificThanIterator: Iterator {}
+
+pub trait Tr {
+    fn foo();
+}
+
+impl<A, Iter> Tr for Iter
+    where
+        Iter: Iterator<Item = A>,
+{
+    default fn foo() {}
+}
+
+impl<A, Iter> Tr for Iter
+    where
+        Iter: MoreSpecificThanIterator<Item = A>,
+{
+    fn foo() {}
+}