rustdoc: Collapse RequiredAssocTy & AssocTy

Author: fmease

src/librustdoc/clean/inline.rs

@@ -391,17 +391,12 @@ fn build_type_alias(
     cx: &mut DocContext<'_>,
     did: DefId,
     ret: &mut Vec<Item>,
-) -> Box<clean::TypeAlias> {
+) -> Box<clean::TyAlias> {
     let ty = cx.tcx.type_of(did).instantiate_identity().skip_norm_wip();
     let type_ = clean_middle_ty(ty::Binder::dummy(ty), cx, Some(did), None);
     let inner_type = clean_ty_alias_inner_type(ty, cx, ret);
 
-    Box::new(clean::TypeAlias {
-        type_,
-        generics: clean_ty_generics(cx, did),
-        inner_type,
-        item_type: None,
-    })
+    Box::new(clean::TyAlias { ty: type_, generics: clean_ty_generics(cx, did), inner_type })
 }
 
 /// Builds all inherent implementations of an ADT (struct/union/enum) or Trait item/path/reexport.

src/librustdoc/clean/mod.rs

@@ -1315,25 +1315,18 @@ fn clean_trait_item<'tcx>(trait_item: &hir::TraitItem<'tcx>, cx: &mut DocContext
                     clean_function(cx, sig, trait_item.generics, params, local_did);
                 ItemKind::AssocFn(Box::new(AssocFn { generics, decl, body }))
             }
-            hir::TraitItemKind::Type(bounds, Some(default)) => {
+            hir::TraitItemKind::Type(bounds, ty) => {
                 let generics = enter_impl_trait(cx, |cx| clean_generics(trait_item.generics, cx));
                 let bounds = bounds.iter().filter_map(|x| clean_generic_bound(x, cx)).collect();
-                let item_type =
-                    clean_middle_ty(ty::Binder::dummy(lower_ty(cx.tcx, default)), cx, None, None);
-                ItemKind::AssocTy(
-                    Box::new(TypeAlias {
-                        type_: clean_ty(default, cx),
-                        generics,
-                        inner_type: None,
-                        item_type: Some(item_type),
-                    }),
+                ItemKind::AssocTy(Box::new(AssocTy {
+                    generics,
                     bounds,
-                )
-            }
-            hir::TraitItemKind::Type(bounds, None) => {
-                let generics = enter_impl_trait(cx, |cx| clean_generics(trait_item.generics, cx));
-                let bounds = bounds.iter().filter_map(|x| clean_generic_bound(x, cx)).collect();
-                ItemKind::RequiredAssocTy(generics, bounds)
+                    ty: ty.map(|ty| {
+                        let middle_ty = ty::Binder::dummy(lower_ty(cx.tcx, ty));
+                        let middle_ty = Some(clean_middle_ty(middle_ty, cx, None, None));
+                        AliasedTy { ty: clean_ty(ty, cx), middle_ty }
+                    }),
+                }))
             }
         };
         Item::from_def_id_and_parts(local_did, Some(trait_item.ident.name), inner, cx.tcx)
@@ -1364,20 +1357,16 @@ pub(crate) fn clean_impl_item<'tcx>(
                     })),
                 }))
             }
-            hir::ImplItemKind::Type(hir_ty) => {
-                let type_ = clean_ty(hir_ty, cx);
+            hir::ImplItemKind::Type(ty) => {
                 let generics = clean_generics(impl_.generics, cx);
-                let item_type =
-                    clean_middle_ty(ty::Binder::dummy(lower_ty(cx.tcx, hir_ty)), cx, None, None);
-                ItemKind::AssocTy(
-                    Box::new(TypeAlias {
-                        type_,
-                        generics,
-                        inner_type: None,
-                        item_type: Some(item_type),
-                    }),
-                    Vec::new(),
-                )
+                let middle_ty =
+                    clean_middle_ty(ty::Binder::dummy(lower_ty(cx.tcx, ty)), cx, None, None);
+                let ty = clean_ty(ty, cx);
+                ItemKind::AssocTy(Box::new(AssocTy {
+                    generics,
+                    bounds: Vec::new(),
+                    ty: Some(AliasedTy { ty, middle_ty: Some(middle_ty) }),
+                }))
             }
         };
 
@@ -1487,7 +1476,7 @@ pub(crate) fn clean_middle_assoc_item(assoc_item: &ty::AssocItem, cx: &mut DocCo
             );
             simplify::move_bounds_to_generic_parameters(&mut generics);
 
-            if let ty::AssocContainer::Trait = assoc_item.container {
+            let (bounds, ty) = if let ty::AssocContainer::Trait = assoc_item.container {
                 // Move bounds that are (likely) directly attached to the associated type
                 // from the where-clause to the associated type.
                 // There is no guarantee that this is what the user actually wrote but we have
@@ -1555,50 +1544,24 @@ pub(crate) fn clean_middle_assoc_item(assoc_item: &ty::AssocItem, cx: &mut DocCo
                     None => bounds.push(GenericBound::maybe_sized(cx)),
                 }
 
-                if tcx.defaultness(assoc_item.def_id).has_value() {
-                    ItemKind::AssocTy(
-                        Box::new(TypeAlias {
-                            type_: clean_middle_ty(
-                                ty::Binder::dummy(
-                                    tcx.type_of(assoc_item.def_id)
-                                        .instantiate_identity()
-                                        .skip_norm_wip(),
-                                ),
-                                cx,
-                                Some(assoc_item.def_id),
-                                None,
-                            ),
-                            generics,
-                            inner_type: None,
-                            item_type: None,
-                        }),
-                        bounds,
-                    )
-                } else {
-                    ItemKind::RequiredAssocTy(generics, bounds)
-                }
+                let ty = tcx.defaultness(assoc_item.def_id).has_value().then(|| {
+                    let ty = tcx.type_of(assoc_item.def_id).instantiate_identity().skip_norm_wip();
+                    clean_middle_ty(ty::Binder::dummy(ty), cx, Some(assoc_item.def_id), None)
+                });
+
+                (bounds, ty)
             } else {
-                ItemKind::AssocTy(
-                    Box::new(TypeAlias {
-                        type_: clean_middle_ty(
-                            ty::Binder::dummy(
-                                tcx.type_of(assoc_item.def_id)
-                                    .instantiate_identity()
-                                    .skip_norm_wip(),
-                            ),
-                            cx,
-                            Some(assoc_item.def_id),
-                            None,
-                        ),
-                        generics,
-                        inner_type: None,
-                        item_type: None,
-                    }),
-                    // Associated types inside trait or inherent impls are not allowed to have
-                    // item bounds. Thus we don't attempt to move any bounds there.
-                    Vec::new(),
-                )
-            }
+                let ty = tcx.type_of(assoc_item.def_id).instantiate_identity().skip_norm_wip();
+                let ty = clean_middle_ty(ty::Binder::dummy(ty), cx, Some(assoc_item.def_id), None);
+                // Associated types inside trait or inherent impls are not allowed to have
+                // item bounds. Thus we don't attempt to move any bounds there.
+                (Vec::new(), Some(ty))
+            };
+            ItemKind::AssocTy(Box::new(AssocTy {
+                generics,
+                bounds,
+                ty: ty.map(|ty| AliasedTy { ty, middle_ty: None }),
+            }))
         }
     };
 
@@ -2948,10 +2911,10 @@ fn clean_maybe_renamed_item<'tcx>(
             })),
             hir::ItemKind::TyAlias(_, generics, ty) => {
                 *cx.current_type_aliases.entry(def_id).or_insert(0) += 1;
-                let rustdoc_ty = clean_ty(ty, cx);
-                let type_ =
-                    clean_middle_ty(ty::Binder::dummy(lower_ty(cx.tcx, ty)), cx, None, None);
+
                 let generics = clean_generics(generics, cx);
+                let type_ = clean_ty(ty, cx);
+
                 if let Some(count) = cx.current_type_aliases.get_mut(&def_id) {
                     *count -= 1;
                     if *count == 0 {
@@ -2960,18 +2923,12 @@ fn clean_maybe_renamed_item<'tcx>(
                 }
 
                 let ty = cx.tcx.type_of(def_id).instantiate_identity().skip_norm_wip();
-
                 let mut ret = Vec::new();
                 let inner_type = clean_ty_alias_inner_type(ty, cx, &mut ret);
 
                 ret.push(generate_item_with_correct_attrs(
                     cx,
-                    ItemKind::TyAlias(Box::new(TypeAlias {
-                        generics,
-                        inner_type,
-                        type_: rustdoc_ty,
-                        item_type: Some(type_),
-                    })),
+                    ItemKind::TyAlias(Box::new(TyAlias { generics, inner_type, ty: type_ })),
                     item.owner_id.def_id.to_def_id(),
                     name,
                     import_ids,

src/librustdoc/clean/types.rs

@@ -646,14 +646,13 @@ impl Item {
     pub(crate) fn is_variant(&self) -> bool {
         self.type_() == ItemType::Variant
     }
-    pub(crate) fn is_associated_type(&self) -> bool {
-        matches!(self.kind, ItemKind::AssocTy(..) | ItemKind::Stripped(ItemKind::AssocTy(..)))
+    pub(crate) fn is_assoc_ty_with_body(&self) -> bool {
+        let kind = if let ItemKind::Stripped(kind) = &self.kind { kind } else { &self.kind };
+        matches!(kind, ItemKind::AssocTy(AssocTy { ty: Some(_), .. }))
     }
-    pub(crate) fn is_required_associated_type(&self) -> bool {
-        matches!(
-            self.kind,
-            ItemKind::RequiredAssocTy(..) | ItemKind::Stripped(ItemKind::RequiredAssocTy(..))
-        )
+    pub(crate) fn is_assoc_ty_without_body(&self) -> bool {
+        let kind = if let ItemKind::Stripped(kind) = &self.kind { kind } else { &self.kind };
+        matches!(kind, ItemKind::AssocTy(AssocTy { ty: None, .. }))
     }
     pub(crate) fn is_assoc_const_with_body(&self) -> bool {
         let kind = if let ItemKind::Stripped(kind) = &self.kind { kind } else { &self.kind };
@@ -861,10 +860,7 @@ impl Item {
             // Variants always inherit visibility
             ItemKind::Variant(..) | ItemKind::Impl(..) => return None,
             // Trait items inherit the trait's visibility
-            ItemKind::AssocConst(..)
-            | ItemKind::AssocTy(..)
-            | ItemKind::RequiredAssocTy(..)
-            | ItemKind::AssocFn(..) => {
+            ItemKind::AssocConst(..) | ItemKind::AssocTy(..) | ItemKind::AssocFn(..) => {
                 match tcx.associated_item(def_id).container {
                     // Trait impl items always inherit the impl's visibility --
                     // we don't want to show `pub`.
@@ -904,7 +900,7 @@ pub(crate) enum ItemKind {
     Enum(Enum),
     Fn(Box<Function>),
     Module(Module),
-    TyAlias(Box<TypeAlias>),
+    TyAlias(Box<TyAlias>),
     Static(Static),
     Trait(Box<Trait>),
     TraitAlias(TraitAlias),
@@ -932,12 +928,7 @@ pub(crate) enum ItemKind {
     Primitive(PrimitiveType),
     Const(Box<Constant>),
     AssocConst(Box<AssocConst>),
-    /// A required associated type in a trait declaration.
-    ///
-    /// The bounds may be non-empty if there is a `where` clause.
-    RequiredAssocTy(Generics, Vec<GenericBound>),
-    /// An associated type in a trait impl or a provided one in a trait declaration.
-    AssocTy(Box<TypeAlias>, Vec<GenericBound>),
+    AssocTy(Box<AssocTy>),
     /// An item that has been stripped by a rustdoc pass
     Stripped(Box<ItemKind>),
     /// This item represents an anonymous constant with a `#[doc(keyword = "...")]` attribute which is used
@@ -980,7 +971,6 @@ impl ItemKind {
             | Self::ProcMacro(_)
             | Self::Primitive(_)
             | Self::AssocConst(..)
-            | Self::RequiredAssocTy(..)
             | Self::AssocTy(..)
             | Self::Stripped(_)
             | Self::Keyword
@@ -2231,19 +2221,28 @@ impl TypeAliasInnerType {
 }
 
 #[derive(Clone, Debug)]
-pub(crate) struct TypeAlias {
-    pub(crate) type_: Type,
+pub(crate) struct TyAlias {
     pub(crate) generics: Generics,
+    pub(crate) ty: Type,
     /// Inner `AdtDef` type, ie `type TyKind = IrTyKind<Adt, Ty>`,
     /// to be shown directly on the typedef page.
     pub(crate) inner_type: Option<TypeAliasInnerType>,
-    /// `type_` can come from either the HIR or from metadata. If it comes from HIR, it may be a type
-    /// alias instead of the final type. This will always have the final type, regardless of whether
-    /// `type_` came from HIR or from metadata.
-    ///
-    /// If `item_type.is_none()`, `type_` is guaranteed to come from metadata (and therefore hold the
-    /// final type).
-    pub(crate) item_type: Option<Type>,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct AssocTy {
+    pub(crate) generics: Generics,
+    pub(crate) bounds: Vec<GenericBound>,
+    pub(crate) ty: Option<AliasedTy>,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct AliasedTy {
+    pub(crate) ty: Type,
+    // FIXME: Somehow get rid of this field.
+    /// Iff [`Self::ty`] was cleaned from the HIR, this contains
+    /// the corresponding type cleaned from the middle::ty IR.
+    pub(crate) middle_ty: Option<Type>,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]

src/librustdoc/clean/utils.rs

@@ -23,8 +23,8 @@ use crate::clean::auto_trait::synthesize_auto_trait_impls;
 use crate::clean::blanket_impl::synthesize_blanket_impls;
 use crate::clean::render_macro_matchers::render_macro_matcher;
 use crate::clean::{
-    AssocItemConstraint, AssocItemConstraintKind, Crate, ExternalCrate, Generic, GenericArg,
-    GenericArgs, ImportSource, Item, ItemKind, Lifetime, Path, PathSegment, Primitive,
+    AssocItemConstraint, AssocItemConstraintKind, AssocTy, Crate, ExternalCrate, Generic,
+    GenericArg, GenericArgs, ImportSource, Item, ItemKind, Lifetime, Path, PathSegment, Primitive,
     PrimitiveType, Term, Type, clean_doc_module, clean_middle_const, clean_middle_region,
     clean_middle_ty, inline,
 };
@@ -275,19 +275,16 @@ pub(crate) fn build_deref_target_impls(
     let tcx = cx.tcx;
 
     for item in items {
-        let target = match item.kind {
-            ItemKind::AssocTy(ref t, _) => &t.type_,
-            _ => continue,
-        };
+        let ItemKind::AssocTy(AssocTy { ty: Some(target), .. }) = &item.kind else { continue };
 
-        if let Some(prim) = target.primitive_type() {
+        if let Some(prim) = target.ty.primitive_type() {
             let _prof_timer = tcx.sess.prof.generic_activity("build_primitive_inherent_impls");
             for did in prim.impls(tcx).filter(|did| !did.is_local()) {
                 cx.with_param_env(did, |cx| {
                     inline::build_impl(cx, did, None, ret);
                 });
             }
-        } else if let Type::Path { path } = target {
+        } else if let Type::Path { path } = &target.ty {
             let did = path.def_id();
             if !did.is_local() {
                 cx.with_param_env(did, |cx| {

src/librustdoc/fold.rs

@@ -91,7 +91,6 @@ pub(crate) trait DocFolder: Sized {
             | ItemKind::ProcMacro(_)
             | ItemKind::Primitive(_)
             | ItemKind::AssocConst(..)
-            | ItemKind::RequiredAssocTy(..)
             | ItemKind::AssocTy(..)
             | ItemKind::Keyword
             | ItemKind::Attribute

src/librustdoc/formats/cache.rs

@@ -448,7 +448,6 @@ impl DocFolder for CacheBuilder<'_, '_> {
             | ItemKind::AssocFn(..)
             | ItemKind::StructField(..)
             | ItemKind::AssocConst(..)
-            | ItemKind::RequiredAssocTy(..)
             | ItemKind::AssocTy(..)
             | ItemKind::Stripped(..)
             | ItemKind::Keyword
@@ -547,15 +546,16 @@ fn add_item_to_search_index(tcx: TyCtxt<'_>, cache: &mut Cache, item: &clean::It
     let item_def_id = item.item_id.as_def_id().unwrap();
     let (parent_did, parent_path) = match item.kind {
         ItemKind::Stripped(..) => return,
-        ItemKind::AssocConst(clean::AssocConst { rhs: Some(_), .. }) | ItemKind::AssocTy(..)
+        ItemKind::AssocConst(clean::AssocConst { rhs: Some(_), .. })
+        | ItemKind::AssocTy(clean::AssocTy { ty: Some(_), .. })
             if cache.parent_stack.last().is_some_and(|parent| parent.is_trait_impl()) =>
         {
             // skip associated items in trait impls
             return;
         }
         ItemKind::AssocFn(clean::AssocFn { body: None, .. })
         | ItemKind::AssocConst(clean::AssocConst { rhs: None, .. })
-        | ItemKind::RequiredAssocTy(..)
+        | ItemKind::AssocTy(clean::AssocTy { ty: None, .. })
         | ItemKind::StructField(..)
         | ItemKind::Variant(..) => {
             // Don't index if containing module is stripped (i.e., private),

src/librustdoc/formats/item_type.rs

@@ -138,7 +138,7 @@ impl<'a> From<&'a clean::Item> for ItemType {
             ItemKind::DeclMacro(..) => ItemType::Macro,
             ItemKind::Primitive(..) => ItemType::Primitive,
             ItemKind::AssocConst(..) => ItemType::AssocConst,
-            ItemKind::RequiredAssocTy(..) | ItemKind::AssocTy(..) => ItemType::AssocType,
+            ItemKind::AssocTy(..) => ItemType::AssocType,
             ItemKind::ForeignTy => ItemType::ForeignType,
             ItemKind::Keyword => ItemType::Keyword,
             ItemKind::Attribute => ItemType::Attribute,