hir_analysis: add missing sizedness bounds

Default sizedness bounds were not being added to
`explicit_super_predicates_of` and `explicit_implied_predicates_of`
which meant that a trait bound added to a associated type projection
would be missing the implied predicate of the default sizedness
supertrait of that trait.

An unexpected consequence of this change was that the check for multiple
principals was now finding an additional `MetaSized` principal when
eagerly expanding trait aliases. Instead of special-casing trait aliases
as different from traits and not adding a `MetaSized` supertrait to trait
aliases, filter out `MetaSized` when lowering `dyn Trait`.

Author: davidtwco

compiler/rustc_hir_analysis/src/collect/item_bounds.rs

@@ -12,7 +12,9 @@ use tracing::{debug, instrument};
 
 use super::ItemCtxt;
 use super::predicates_of::assert_only_contains_predicates_from;
-use crate::hir_ty_lowering::{HirTyLowerer, OverlappingAsssocItemConstraints, PredicateFilter};
+use crate::hir_ty_lowering::{
+    HirTyLowerer, ImpliedBoundsContext, OverlappingAsssocItemConstraints, PredicateFilter,
+};
 
 /// For associated types we include both bounds written on the type
 /// (`type X: Trait`) and predicates from the trait: `where Self::X: Trait`.
@@ -52,15 +54,20 @@ fn associated_type_bounds<'tcx>(
             | PredicateFilter::SelfTraitThatDefines(_)
             | PredicateFilter::SelfAndAssociatedTypeBounds => {
                 // Implicit bounds are added to associated types unless a `?Trait` bound is found.
-                icx.lowerer().add_sizedness_bounds(
+                icx.lowerer().add_implicit_sizedness_bounds(
+                    &mut bounds,
+                    item_ty,
+                    hir_bounds,
+                    ImpliedBoundsContext::AssociatedTypeOrImplTrait,
+                    span,
+                );
+                icx.lowerer().add_default_traits(
                     &mut bounds,
                     item_ty,
                     hir_bounds,
-                    None,
-                    None,
+                    ImpliedBoundsContext::AssociatedTypeOrImplTrait,
                     span,
                 );
-                icx.lowerer().add_default_traits(&mut bounds, item_ty, hir_bounds, None, span);
 
                 // Also collect `where Self::Assoc: Trait` from the parent trait's where clauses.
                 let trait_def_id = tcx.local_parent(assoc_item_def_id);
@@ -372,15 +379,20 @@ fn opaque_type_bounds<'tcx>(
             | PredicateFilter::SelfOnly
             | PredicateFilter::SelfTraitThatDefines(_)
             | PredicateFilter::SelfAndAssociatedTypeBounds => {
-                icx.lowerer().add_sizedness_bounds(
+                icx.lowerer().add_implicit_sizedness_bounds(
+                    &mut bounds,
+                    item_ty,
+                    hir_bounds,
+                    ImpliedBoundsContext::AssociatedTypeOrImplTrait,
+                    span,
+                );
+                icx.lowerer().add_default_traits(
                     &mut bounds,
                     item_ty,
                     hir_bounds,
-                    None,
-                    None,
+                    ImpliedBoundsContext::AssociatedTypeOrImplTrait,
                     span,
                 );
-                icx.lowerer().add_default_traits(&mut bounds, item_ty, hir_bounds, None, span);
             }
             //`ConstIfConst` is only interested in `[const]` bounds.
             PredicateFilter::ConstIfConst | PredicateFilter::SelfConstIfConst => {}

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -19,7 +19,8 @@ use crate::collect::ItemCtxt;
 use crate::constrained_generic_params as cgp;
 use crate::delegation::inherit_predicates_for_delegation_item;
 use crate::hir_ty_lowering::{
-    HirTyLowerer, OverlappingAsssocItemConstraints, PredicateFilter, RegionInferReason,
+    HirTyLowerer, ImpliedBoundsContext, OverlappingAsssocItemConstraints, PredicateFilter,
+    RegionInferReason,
 };
 
 /// Returns a list of all type predicates (explicit and implicit) for the definition with
@@ -189,12 +190,11 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
             PredicateFilter::All,
             OverlappingAsssocItemConstraints::Allowed,
         );
-        icx.lowerer().add_sizedness_bounds(
+        icx.lowerer().add_implicit_sizedness_bounds(
             &mut bounds,
             tcx.types.self_param,
             self_bounds,
-            None,
-            Some(def_id),
+            ImpliedBoundsContext::TraitDef(def_id),
             span,
         );
         icx.lowerer().add_default_super_traits(
@@ -229,19 +229,18 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
                 let param_ty = icx.lowerer().lower_ty_param(param.hir_id);
                 let mut bounds = Vec::new();
                 // Implicit bounds are added to type params unless a `?Trait` bound is found
-                icx.lowerer().add_sizedness_bounds(
+                icx.lowerer().add_implicit_sizedness_bounds(
                     &mut bounds,
                     param_ty,
                     &[],
-                    Some((param.def_id, hir_generics.predicates)),
-                    None,
+                    ImpliedBoundsContext::TyParam(param.def_id, hir_generics.predicates),
                     param.span,
                 );
                 icx.lowerer().add_default_traits(
                     &mut bounds,
                     param_ty,
                     &[],
-                    Some((param.def_id, hir_generics.predicates)),
+                    ImpliedBoundsContext::TyParam(param.def_id, hir_generics.predicates),
                     param.span,
                 );
                 trace!(?bounds);
@@ -676,6 +675,13 @@ pub(super) fn implied_predicates_with_filter<'tcx>(
         | PredicateFilter::SelfOnly
         | PredicateFilter::SelfTraitThatDefines(_)
         | PredicateFilter::SelfAndAssociatedTypeBounds => {
+            icx.lowerer().add_implicit_sizedness_bounds(
+                &mut bounds,
+                self_param_ty,
+                superbounds,
+                ImpliedBoundsContext::TraitDef(trait_def_id),
+                item.span,
+            );
             icx.lowerer().add_default_super_traits(
                 trait_def_id,
                 &mut bounds,

compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs

@@ -18,11 +18,10 @@ use rustc_trait_selection::traits;
 use smallvec::SmallVec;
 use tracing::{debug, instrument};
 
-use super::errors::GenericsArgsErrExtend;
 use crate::errors;
 use crate::hir_ty_lowering::{
-    AssocItemQSelf, FeedConstTy, HirTyLowerer, OverlappingAsssocItemConstraints, PredicateFilter,
-    RegionInferReason,
+    AssocItemQSelf, FeedConstTy, GenericsArgsErrExtend, HirTyLowerer, ImpliedBoundsContext,
+    OverlappingAsssocItemConstraints, PredicateFilter, RegionInferReason,
 };
 
 #[derive(Debug, Default)]
@@ -62,7 +61,7 @@ impl CollectedSizednessBounds {
 
 fn search_bounds_for<'tcx>(
     hir_bounds: &'tcx [hir::GenericBound<'tcx>],
-    self_ty_where_predicates: Option<(LocalDefId, &'tcx [hir::WherePredicate<'tcx>])>,
+    context: ImpliedBoundsContext<'tcx>,
     mut f: impl FnMut(&'tcx PolyTraitRef<'tcx>),
 ) {
     let mut search_bounds = |hir_bounds: &'tcx [hir::GenericBound<'tcx>]| {
@@ -76,7 +75,7 @@ fn search_bounds_for<'tcx>(
     };
 
     search_bounds(hir_bounds);
-    if let Some((self_ty, where_clause)) = self_ty_where_predicates {
+    if let ImpliedBoundsContext::TyParam(self_ty, where_clause) = context {
         for clause in where_clause {
             if let hir::WherePredicateKind::BoundPredicate(pred) = clause.kind
                 && pred.is_param_bound(self_ty.to_def_id())
@@ -89,10 +88,10 @@ fn search_bounds_for<'tcx>(
 
 fn collect_relaxed_bounds<'tcx>(
     hir_bounds: &'tcx [hir::GenericBound<'tcx>],
-    self_ty_where_predicates: Option<(LocalDefId, &'tcx [hir::WherePredicate<'tcx>])>,
+    context: ImpliedBoundsContext<'tcx>,
 ) -> SmallVec<[&'tcx PolyTraitRef<'tcx>; 1]> {
     let mut relaxed_bounds: SmallVec<[_; 1]> = SmallVec::new();
-    search_bounds_for(hir_bounds, self_ty_where_predicates, |ptr| {
+    search_bounds_for(hir_bounds, context, |ptr| {
         if matches!(ptr.modifiers.polarity, hir::BoundPolarity::Maybe(_)) {
             relaxed_bounds.push(ptr);
         }
@@ -102,11 +101,11 @@ fn collect_relaxed_bounds<'tcx>(
 
 fn collect_bounds<'a, 'tcx>(
     hir_bounds: &'a [hir::GenericBound<'tcx>],
-    self_ty_where_predicates: Option<(LocalDefId, &'tcx [hir::WherePredicate<'tcx>])>,
+    context: ImpliedBoundsContext<'tcx>,
     target_did: DefId,
 ) -> CollectedBound {
     let mut collect_into = CollectedBound::default();
-    search_bounds_for(hir_bounds, self_ty_where_predicates, |ptr| {
+    search_bounds_for(hir_bounds, context, |ptr| {
         if !matches!(ptr.trait_ref.path.res, Res::Def(DefKind::Trait, did) if did == target_did) {
             return;
         }
@@ -123,17 +122,17 @@ fn collect_bounds<'a, 'tcx>(
 fn collect_sizedness_bounds<'tcx>(
     tcx: TyCtxt<'tcx>,
     hir_bounds: &'tcx [hir::GenericBound<'tcx>],
-    self_ty_where_predicates: Option<(LocalDefId, &'tcx [hir::WherePredicate<'tcx>])>,
+    context: ImpliedBoundsContext<'tcx>,
     span: Span,
 ) -> CollectedSizednessBounds {
     let sized_did = tcx.require_lang_item(hir::LangItem::Sized, span);
-    let sized = collect_bounds(hir_bounds, self_ty_where_predicates, sized_did);
+    let sized = collect_bounds(hir_bounds, context, sized_did);
 
     let meta_sized_did = tcx.require_lang_item(hir::LangItem::MetaSized, span);
-    let meta_sized = collect_bounds(hir_bounds, self_ty_where_predicates, meta_sized_did);
+    let meta_sized = collect_bounds(hir_bounds, context, meta_sized_did);
 
     let pointee_sized_did = tcx.require_lang_item(hir::LangItem::PointeeSized, span);
-    let pointee_sized = collect_bounds(hir_bounds, self_ty_where_predicates, pointee_sized_did);
+    let pointee_sized = collect_bounds(hir_bounds, context, pointee_sized_did);
 
     CollectedSizednessBounds { sized, meta_sized, pointee_sized }
 }
@@ -161,13 +160,12 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     ///   bounds are present.
     /// - On parameters, opaque type, associated types and trait aliases, add a `MetaSized` bound if
     ///   a `?Sized` bound is present.
-    pub(crate) fn add_sizedness_bounds(
+    pub(crate) fn add_implicit_sizedness_bounds(
         &self,
         bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
         self_ty: Ty<'tcx>,
         hir_bounds: &'tcx [hir::GenericBound<'tcx>],
-        self_ty_where_predicates: Option<(LocalDefId, &'tcx [hir::WherePredicate<'tcx>])>,
-        trait_did: Option<LocalDefId>,
+        context: ImpliedBoundsContext<'tcx>,
         span: Span,
     ) {
         let tcx = self.tcx();
@@ -181,33 +179,36 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         let pointee_sized_did = tcx.require_lang_item(hir::LangItem::PointeeSized, span);
 
         // If adding sizedness bounds to a trait, then there are some relevant early exits
-        if let Some(trait_did) = trait_did {
-            let trait_did = trait_did.to_def_id();
-            // Never add a default supertrait to `PointeeSized`.
-            if trait_did == pointee_sized_did {
-                return;
+        match context {
+            ImpliedBoundsContext::TraitDef(trait_did) => {
+                let trait_did = trait_did.to_def_id();
+                // Never add a default supertrait to `PointeeSized`.
+                if trait_did == pointee_sized_did {
+                    return;
+                }
+                // Don't add default sizedness supertraits to auto traits because it isn't possible to
+                // relax an automatically added supertrait on the defn itself.
+                if tcx.trait_is_auto(trait_did) {
+                    return;
+                }
             }
-            // Don't add default sizedness supertraits to auto traits because it isn't possible to
-            // relax an automatically added supertrait on the defn itself.
-            if tcx.trait_is_auto(trait_did) {
-                return;
+            ImpliedBoundsContext::TyParam(..) | ImpliedBoundsContext::AssociatedTypeOrImplTrait => {
+                // Report invalid relaxed bounds.
+                // FIXME: Since we only call this validation function here in this function, we only
+                //        fully validate relaxed bounds in contexts where we perform
+                //        "sized elaboration". In most cases that doesn't matter because we *usually*
+                //        reject such relaxed bounds outright during AST lowering.
+                //        However, this can easily get out of sync! Ideally, we would perform this step
+                //        where we are guaranteed to catch *all* bounds like in
+                //        `Self::lower_poly_trait_ref`. List of concrete issues:
+                //        FIXME(more_maybe_bounds): We don't call this for trait object tys, supertrait
+                //                                  bounds, trait alias bounds, assoc type bounds (ATB)!
+                let bounds = collect_relaxed_bounds(hir_bounds, context);
+                self.reject_duplicate_relaxed_bounds(bounds);
             }
-        } else {
-            // Report invalid relaxed bounds.
-            // FIXME: Since we only call this validation function here in this function, we only
-            //        fully validate relaxed bounds in contexts where we perform
-            //        "sized elaboration". In most cases that doesn't matter because we *usually*
-            //        reject such relaxed bounds outright during AST lowering.
-            //        However, this can easily get out of sync! Ideally, we would perform this step
-            //        where we are guaranteed to catch *all* bounds like in
-            //        `Self::lower_poly_trait_ref`. List of concrete issues:
-            //        FIXME(more_maybe_bounds): We don't call this for trait object tys, supertrait
-            //                                  bounds, trait alias bounds, assoc type bounds (ATB)!
-            let bounds = collect_relaxed_bounds(hir_bounds, self_ty_where_predicates);
-            self.reject_duplicate_relaxed_bounds(bounds);
         }
 
-        let collected = collect_sizedness_bounds(tcx, hir_bounds, self_ty_where_predicates, span);
+        let collected = collect_sizedness_bounds(tcx, hir_bounds, context, span);
         if (collected.sized.maybe || collected.sized.negative)
             && !collected.sized.positive
             && !collected.meta_sized.any()
@@ -217,15 +218,19 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             // other explicit ones) - this can happen for trait aliases as well as bounds.
             add_trait_bound(tcx, bounds, self_ty, meta_sized_did, span);
         } else if !collected.any() {
-            if trait_did.is_some() {
-                // If there are no explicit sizedness bounds on a trait then add a default
-                // `MetaSized` supertrait.
-                add_trait_bound(tcx, bounds, self_ty, meta_sized_did, span);
-            } else {
-                // If there are no explicit sizedness bounds on a parameter then add a default
-                // `Sized` bound.
-                let sized_did = tcx.require_lang_item(hir::LangItem::Sized, span);
-                add_trait_bound(tcx, bounds, self_ty, sized_did, span);
+            match context {
+                ImpliedBoundsContext::TraitDef(..) => {
+                    // If there are no explicit sizedness bounds on a trait then add a default
+                    // `MetaSized` supertrait.
+                    add_trait_bound(tcx, bounds, self_ty, meta_sized_did, span);
+                }
+                ImpliedBoundsContext::TyParam(..)
+                | ImpliedBoundsContext::AssociatedTypeOrImplTrait => {
+                    // If there are no explicit sizedness bounds on a parameter then add a default
+                    // `Sized` bound.
+                    let sized_did = tcx.require_lang_item(hir::LangItem::Sized, span);
+                    add_trait_bound(tcx, bounds, self_ty, sized_did, span);
+                }
             }
         }
     }
@@ -251,7 +256,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             bounds,
             self.tcx().types.self_param,
             hir_bounds,
-            Some((trait_def_id, hir_generics.predicates)),
+            ImpliedBoundsContext::TyParam(trait_def_id, hir_generics.predicates),
             span,
         );
     }
@@ -261,18 +266,11 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
         self_ty: Ty<'tcx>,
         hir_bounds: &[hir::GenericBound<'tcx>],
-        self_ty_where_predicates: Option<(LocalDefId, &'tcx [hir::WherePredicate<'tcx>])>,
+        context: ImpliedBoundsContext<'tcx>,
         span: Span,
     ) {
         self.tcx().default_traits().iter().for_each(|default_trait| {
-            self.add_default_trait(
-                *default_trait,
-                bounds,
-                self_ty,
-                hir_bounds,
-                self_ty_where_predicates,
-                span,
-            );
+            self.add_default_trait(*default_trait, bounds, self_ty, hir_bounds, context, span);
         });
     }
 
@@ -285,13 +283,13 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
         self_ty: Ty<'tcx>,
         hir_bounds: &[hir::GenericBound<'tcx>],
-        self_ty_where_predicates: Option<(LocalDefId, &'tcx [hir::WherePredicate<'tcx>])>,
+        context: ImpliedBoundsContext<'tcx>,
         span: Span,
     ) {
         let tcx = self.tcx();
         let trait_id = tcx.lang_items().get(trait_);
         if let Some(trait_id) = trait_id
-            && self.should_add_default_traits(trait_id, hir_bounds, self_ty_where_predicates)
+            && self.should_add_default_traits(trait_id, hir_bounds, context)
         {
             add_trait_bound(tcx, bounds, self_ty, trait_id, span);
         }
@@ -302,9 +300,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         &self,
         trait_def_id: DefId,
         hir_bounds: &'a [hir::GenericBound<'tcx>],
-        self_ty_where_predicates: Option<(LocalDefId, &'tcx [hir::WherePredicate<'tcx>])>,
+        context: ImpliedBoundsContext<'tcx>,
     ) -> bool {
-        let collected = collect_bounds(hir_bounds, self_ty_where_predicates, trait_def_id);
+        let collected = collect_bounds(hir_bounds, context, trait_def_id);
         !self.tcx().has_attr(CRATE_DEF_ID, sym::rustc_no_implicit_bounds) && !collected.any()
     }