Auto merge of #148379 - obi1kenobi:pg/implied-bounds, r=<try>

Add implied bounds to generic types, impl Trait, and assoc types.

Author: bors

src/librustdoc/clean/mod.rs

@@ -42,7 +42,7 @@ use rustc_hir as hir;
 use rustc_hir::attrs::{AttributeKind, DocAttribute, DocInline};
 use rustc_hir::def::{CtorKind, DefKind, MacroKinds, Res};
 use rustc_hir::def_id::{DefId, DefIdMap, DefIdSet, LOCAL_CRATE, LocalDefId};
-use rustc_hir::{LangItem, PredicateOrigin, find_attr};
+use rustc_hir::{LangItem, OpaqueTyOrigin, PredicateOrigin, find_attr};
 use rustc_hir_analysis::{lower_const_arg_for_rustdoc, lower_ty};
 use rustc_middle::metadata::Reexport;
 use rustc_middle::middle::resolve_bound_vars as rbv;
@@ -458,7 +458,7 @@ fn clean_type_outlives_predicate<'tcx>(
     }
 }
 
-fn clean_middle_term<'tcx>(
+pub(crate) fn clean_middle_term<'tcx>(
     term: ty::Binder<'tcx, ty::Term<'tcx>>,
     cx: &mut DocContext<'tcx>,
 ) -> Term {
@@ -526,7 +526,7 @@ fn should_fully_qualify_path(self_def_id: Option<DefId>, trait_: &Path, self_typ
             .map_or(!self_type.is_self_type(), |(id, trait_)| id != trait_)
 }
 
-fn projection_to_path_segment<'tcx>(
+pub(crate) fn projection_to_path_segment<'tcx>(
     proj: ty::Binder<'tcx, ty::AliasTerm<'tcx>>,
     cx: &mut DocContext<'tcx>,
 ) -> PathSegment {
@@ -698,8 +698,13 @@ pub(crate) fn clean_generics<'tcx>(
             let param = clean_generic_param(cx, Some(gens), param);
             match param.kind {
                 GenericParamDefKind::Lifetime { .. } => unreachable!(),
-                GenericParamDefKind::Type { ref bounds, .. } => {
-                    cx.impl_trait_bounds.insert(param.def_id.into(), bounds.to_vec());
+                GenericParamDefKind::Type { ref bounds, ref synthetic, .. } => {
+                    debug_assert!(*synthetic, "non-synthetic generic for impl trait: {param:?}");
+                    let param_def_id = param.def_id;
+                    cx.impl_trait_bounds.insert(
+                        param_def_id.into(),
+                        (bounds.to_vec(), ImplTraitOrigin::Param { def_id: param_def_id }),
+                    );
                 }
                 GenericParamDefKind::Const { .. } => unreachable!(),
             }
@@ -819,7 +824,7 @@ fn clean_ty_generics_inner<'tcx>(
 ) -> Generics {
     // Don't populate `cx.impl_trait_bounds` before cleaning where clauses,
     // since `clean_predicate` would consume them.
-    let mut impl_trait = BTreeMap::<u32, Vec<GenericBound>>::default();
+    let mut impl_trait = BTreeMap::<u32, (DefId, Vec<GenericBound>)>::default();
 
     let params: ThinVec<_> = gens
         .own_params
@@ -832,7 +837,7 @@ fn clean_ty_generics_inner<'tcx>(
                     return false;
                 }
                 if synthetic {
-                    impl_trait.insert(param.index, vec![]);
+                    impl_trait.insert(param.index, (param.def_id, vec![]));
                     return false;
                 }
                 true
@@ -873,7 +878,7 @@ fn clean_ty_generics_inner<'tcx>(
             };
 
             if let Some(param_idx) = param_idx
-                && let Some(bounds) = impl_trait.get_mut(&param_idx)
+                && let Some((_, bounds)) = impl_trait.get_mut(&param_idx)
             {
                 let pred = clean_predicate(*pred, cx)?;
 
@@ -895,7 +900,7 @@ fn clean_ty_generics_inner<'tcx>(
         })
         .collect::<Vec<_>>();
 
-    for (idx, mut bounds) in impl_trait {
+    for (idx, (param_def_id, mut bounds)) in impl_trait {
         let mut has_sized = false;
         bounds.retain(|b| {
             if b.is_sized_bound(cx) {
@@ -929,7 +934,8 @@ fn clean_ty_generics_inner<'tcx>(
             }
         }
 
-        cx.impl_trait_bounds.insert(idx.into(), bounds);
+        cx.impl_trait_bounds
+            .insert(idx.into(), (bounds, ImplTraitOrigin::Param { def_id: param_def_id }));
     }
 
     // Now that `cx.impl_trait_bounds` is populated, we can process
@@ -1157,7 +1163,7 @@ fn clean_poly_fn_sig<'tcx>(
     // function isn't async without needing to execute the query `asyncness` at
     // all which gives us a noticeable performance boost.
     if let Some(did) = did
-        && let Type::ImplTrait(_) = output
+        && let Type::ImplTrait { .. } = output
         && cx.tcx.asyncness(did).is_async()
     {
         output = output.sugared_async_return_type();
@@ -1648,8 +1654,8 @@ fn clean_qpath<'tcx>(hir_ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> Type
                 if let Some(new_ty) = cx.args.get(&did).and_then(|p| p.as_ty()).cloned() {
                     return new_ty;
                 }
-                if let Some(bounds) = cx.impl_trait_bounds.remove(&did.into()) {
-                    return ImplTrait(bounds);
+                if let Some((bounds, origin)) = cx.impl_trait_bounds.remove(&did.into()) {
+                    return ImplTrait { bounds, origin };
                 }
             }
 
@@ -1838,7 +1844,15 @@ pub(crate) fn clean_ty<'tcx>(ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> T
         }
         TyKind::Tup(tys) => Tuple(tys.iter().map(|ty| clean_ty(ty, cx)).collect()),
         TyKind::OpaqueDef(ty) => {
-            ImplTrait(ty.bounds.iter().filter_map(|x| clean_generic_bound(x, cx)).collect())
+            let bounds =
+                ty.bounds.iter().filter_map(|x| clean_generic_bound(x, cx)).collect::<Vec<_>>();
+            ImplTrait {
+                bounds,
+                origin: ImplTraitOrigin::Opaque {
+                    def_id: ty.def_id.to_def_id(),
+                    needs_sized_check: opaque_needs_sized_check(&ty.origin),
+                },
+            }
         }
         TyKind::Path(_) => clean_qpath(ty, cx),
         TyKind::TraitObject(bounds, lifetime) => {
@@ -2226,8 +2240,8 @@ pub(crate) fn clean_middle_ty<'tcx>(
         }
 
         ty::Param(ref p) => {
-            if let Some(bounds) = cx.impl_trait_bounds.remove(&p.index.into()) {
-                ImplTrait(bounds)
+            if let Some((bounds, origin)) = cx.impl_trait_bounds.remove(&p.index.into()) {
+                ImplTrait { bounds, origin }
             } else if p.name == kw::SelfUpper {
                 SelfTy
             } else {
@@ -2363,7 +2377,24 @@ fn clean_middle_opaque_bounds<'tcx>(
         ));
     }
 
-    ImplTrait(bounds)
+    ImplTrait {
+        bounds,
+        origin: ImplTraitOrigin::Opaque {
+            def_id: impl_trait_def_id,
+            needs_sized_check: if cx.tcx.opt_rpitit_info(impl_trait_def_id).is_some() {
+                // RPITIT uses can imply `Sized` unless used behind indirection,
+                // so a precise check is necessary.
+                true
+            } else if impl_trait_def_id.is_local() {
+                opaque_needs_sized_check(&cx.tcx.opaque_ty_origin(impl_trait_def_id))
+            } else {
+                // Extern opaques don't carry origin metadata.
+                // Skip the use-site check to avoid an ICE.
+                // FIXME: Get metadata on sizedness for extern opaques, then make this precise.
+                false
+            },
+        },
+    }
 }
 
 pub(crate) fn clean_field<'tcx>(field: &hir::FieldDef<'tcx>, cx: &mut DocContext<'tcx>) -> Item {
@@ -2626,6 +2657,17 @@ fn clean_unsafe_binder_ty<'tcx>(
     UnsafeBinderTy { generic_params, ty }
 }
 
+fn opaque_needs_sized_check<D>(origin: &OpaqueTyOrigin<D>) -> bool {
+    match origin {
+        // Return-position opaques need a sizedness check at their use-site,
+        // even if they have a `?Sized` bound.
+        OpaqueTyOrigin::FnReturn { .. } | OpaqueTyOrigin::AsyncFn { .. } => true,
+        // TAITs don't need a use-site sizedness check.
+        // `?Sized` in their definition always opts them out of being sized.
+        OpaqueTyOrigin::TyAlias { .. } => false,
+    }
+}
+
 pub(crate) fn reexport_chain(
     tcx: TyCtxt<'_>,
     import_def_id: LocalDefId,
@@ -3177,7 +3219,7 @@ fn clean_assoc_item_constraint<'tcx>(
     }
 }
 
-fn clean_bound_vars<'tcx>(
+pub(crate) fn clean_bound_vars<'tcx>(
     bound_vars: &ty::List<ty::BoundVariableKind>,
     cx: &mut DocContext<'tcx>,
 ) -> Vec<GenericParamDef> {

src/librustdoc/clean/types.rs

@@ -1292,6 +1292,31 @@ pub(crate) struct PolyTrait {
     pub(crate) generic_params: Vec<GenericParamDef>,
 }
 
+#[derive(Clone, PartialEq, Eq, Hash, Debug)]
+pub(crate) enum ImplTraitOrigin {
+    /// Synthetic type parameter for `impl Trait` in argument position.
+    Param { def_id: DefId },
+
+    /// Opaque type backing `impl Trait`, such as in RPIT or TAIT.
+    ///
+    /// `impl Trait` uses are `Sized` by default, but they can opt out via a `?Sized` bound.
+    /// `needs_sized_check` is `true` when the opaque is in a category that requires a
+    /// point-of-use sizedness check to determine if an implied `Sized` bound is added.
+    ///
+    /// `needs_sized_check = true` occurs in cases like:
+    /// - RPIT: `fn f() -> impl Debug { 0u8 }`
+    /// - RPITIT: `trait T { fn f(&self) -> impl Debug; }`
+    ///
+    /// `needs_sized_check = false` occurs in cases like:
+    /// - TAIT/ATPIT: `type Alias = impl Debug + ?Sized;`
+    ///
+    /// A `true` value for `needs_sized_check` does not guarantee the opaque is `Sized`.
+    /// For example, `fn f() -> &(impl Debug + ?Sized) { "hi" }` has a return-position opaque
+    /// which makes `needs_sized_check = true`, but as the opaque is behind a reference,
+    /// it does not end up getting a `Sized` bound.
+    Opaque { def_id: DefId, needs_sized_check: bool },
+}
+
 /// Rustdoc's representation of types, mostly based on the [`hir::Ty`].
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub(crate) enum Type {
@@ -1337,7 +1362,25 @@ pub(crate) enum Type {
     Infer,
 
     /// An `impl Trait`: `impl TraitA + TraitB + ...`
-    ImplTrait(Vec<GenericBound>),
+    ImplTrait {
+        /// The bounds that are syntactically present:
+        /// ```rust
+        /// # trait TraitA {}
+        /// # trait TraitB {}
+        /// # struct Both;
+        /// # impl TraitA for Both {}
+        /// # impl TraitB for Both {}
+        /// fn example() -> impl TraitA + TraitB {
+        ///     //               ^^^^^^   ^^^^^^
+        ///     // ...
+        /// #   Both
+        /// }
+        /// ```
+        bounds: Vec<GenericBound>,
+        /// Whether this `impl Trait` is syntactic sugar for an anonymous generic parameter,
+        /// or represents an opaque type.
+        origin: ImplTraitOrigin,
+    },
 
     UnsafeBinder(Box<UnsafeBinderTy>),
 }
@@ -1465,8 +1508,8 @@ impl Type {
     /// This function will panic if the return type does not match the expected sugaring for async
     /// functions.
     pub(crate) fn sugared_async_return_type(self) -> Type {
-        if let Type::ImplTrait(mut v) = self
-            && let Some(GenericBound::TraitBound(PolyTrait { mut trait_, .. }, _)) = v.pop()
+        if let Type::ImplTrait { mut bounds, .. } = self
+            && let Some(GenericBound::TraitBound(PolyTrait { mut trait_, .. }, _)) = bounds.pop()
             && let Some(segment) = trait_.segments.pop()
             && let GenericArgs::AngleBracketed { mut constraints, .. } = segment.args
             && let Some(constraint) = constraints.pop()
@@ -1536,7 +1579,7 @@ impl Type {
             Type::Pat(..) => PrimitiveType::Pat,
             RawPointer(..) => PrimitiveType::RawPointer,
             QPath(box QPathData { self_type, .. }) => return self_type.def_id(cache),
-            Generic(_) | SelfTy | Infer | ImplTrait(_) | UnsafeBinder(_) => return None,
+            Generic(_) | SelfTy | Infer | ImplTrait { .. } | UnsafeBinder(_) => return None,
         };
         Primitive(t).def_id(cache)
     }
@@ -2392,14 +2435,14 @@ mod size_asserts {
     // tidy-alphabetical-start
     static_assert_size!(Crate, 16); // frequently moved by-value
     static_assert_size!(DocFragment, 48);
-    static_assert_size!(GenericArg, 32);
+    static_assert_size!(GenericArg, 40);
     static_assert_size!(GenericArgs, 24);
     static_assert_size!(GenericParamDef, 40);
     static_assert_size!(Generics, 16);
     static_assert_size!(Item, 8);
     static_assert_size!(ItemInner, 144);
     static_assert_size!(ItemKind, 48);
     static_assert_size!(PathSegment, 32);
-    static_assert_size!(Type, 32);
+    static_assert_size!(Type, 40);
     // tidy-alphabetical-end
 }

src/librustdoc/core.rs

@@ -54,8 +54,10 @@ pub(crate) struct DocContext<'tcx> {
     // therefore wouldn't use the corresp. generic arg anyway. Add support for them.
     pub(crate) args: DefIdMap<clean::GenericArg>,
     pub(crate) current_type_aliases: DefIdMap<usize>,
-    /// Table synthetic type parameter for `impl Trait` in argument position -> bounds
-    pub(crate) impl_trait_bounds: FxHashMap<ImplTraitParam, Vec<clean::GenericBound>>,
+    /// Table of synthetic type parameter
+    /// for `impl Trait` in argument position -> (bounds, trait origin)
+    pub(crate) impl_trait_bounds:
+        FxHashMap<ImplTraitParam, (Vec<clean::GenericBound>, clean::ImplTraitOrigin)>,
     /// Auto-trait or blanket impls processed so far, as `(self_ty, trait_def_id)`.
     // FIXME(eddyb) make this a `ty::TraitRef<'tcx>` set.
     pub(crate) generated_synthetics: FxHashSet<(Ty<'tcx>, DefId)>,

src/librustdoc/html/format.rs

@@ -1015,15 +1015,15 @@ fn fmt_type(
                 {
                     true
                 }
-                clean::ImplTrait(ref bounds) if bounds.len() > 1 => true,
+                clean::ImplTrait { ref bounds, .. } if bounds.len() > 1 => true,
                 _ => false,
             };
             Wrapped::with_parens()
                 .when(needs_parens)
                 .wrap_fn(|f| fmt_type(ty, f, use_absolute, cx))
                 .fmt(f)
         }
-        clean::ImplTrait(bounds) => {
+        clean::ImplTrait { bounds, .. } => {
             f.write_str("impl ")?;
             print_generic_bounds(bounds, cx).fmt(f)
         }

src/librustdoc/html/render/search_index.rs

@@ -2043,7 +2043,7 @@ fn get_index_type_id(
         clean::Type::Pat(..)
         | clean::Generic(_)
         | clean::SelfTy
-        | clean::ImplTrait(_)
+        | clean::ImplTrait { .. }
         | clean::Infer
         | clean::UnsafeBinder(_) => None,
     }
@@ -2141,7 +2141,7 @@ fn simplify_fn_type<'a, 'tcx>(
                 RenderType { id: Some(RenderTypeId::Index(idx)), generics: None, bindings: None }
             })
         }
-        Type::ImplTrait(ref bounds) => {
+        Type::ImplTrait { ref bounds, .. } => {
             let type_bounds = bounds
                 .iter()
                 .filter_map(|bound| bound.get_trait_path())