[WIP] Collapse RequiredAssocTy & AssocTy

Author: fmease

src/librustdoc/clean/inline.rs

@@ -388,12 +388,7 @@ fn build_type_alias(
     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::TypeAlias { 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

@@ -1297,22 +1297,24 @@ fn clean_trait_item<'tcx>(trait_item: &hir::TraitItem<'tcx>, cx: &mut DocContext
             hir::TraitItemKind::Type(bounds, Some(default)) => {
                 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 =
+                let type_from_middle =
                     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,
-                )
+                    type_: Some(clean_ty(default, cx)),
+                    type_guaranteed_to_come_from_middle: Some(type_from_middle),
+                }))
             }
             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)
+                ItemKind::AssocTy(Box::new(AssocTy {
+                    generics,
+                    bounds,
+                    type_: None,
+                    type_guaranteed_to_come_from_middle: None,
+                }))
             }
         };
         Item::from_def_id_and_parts(local_did, Some(trait_item.ident.name), inner, cx.tcx)
@@ -1342,17 +1344,14 @@ pub(crate) fn clean_impl_item<'tcx>(
             hir::ImplItemKind::Type(hir_ty) => {
                 let type_ = clean_ty(hir_ty, cx);
                 let generics = clean_generics(impl_.generics, cx);
-                let item_type =
+                let type_from_middle =
                     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(),
-                )
+                ItemKind::AssocTy(Box::new(AssocTy {
+                    generics,
+                    bounds: Vec::new(),
+                    type_: Some(type_),
+                    type_guaranteed_to_come_from_middle: Some(type_from_middle),
+                }))
             }
         };
 
@@ -1462,7 +1461,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, type_) = 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
@@ -1530,50 +1529,27 @@ 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 type_ = 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, type_)
             } 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(),
-                )
-            }
+                // Associated types inside trait or inherent impls are not allowed to have
+                // item bounds. Thus we don't attempt to move any bounds there.
+                let bounds = Vec::new();
+                let ty = tcx.type_of(assoc_item.def_id).instantiate_identity().skip_norm_wip();
+                let type_ =
+                    clean_middle_ty(ty::Binder::dummy(ty), cx, Some(assoc_item.def_id), None);
+                (bounds, Some(type_))
+            };
+            ItemKind::AssocTy(Box::new(AssocTy {
+                generics,
+                bounds,
+                type_,
+                type_guaranteed_to_come_from_middle: None,
+            }))
         }
     };
 
@@ -2893,10 +2869,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 {
@@ -2905,18 +2881,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(TypeAlias { generics, inner_type, type_ })),
                     item.owner_id.def_id.to_def_id(),
                     name,
                     import_ids,

src/librustdoc/clean/types.rs

@@ -645,14 +645,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 { type_: 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 { type_: None, .. }))
     }
     pub(crate) fn is_assoc_const_with_body(&self) -> bool {
         let kind = if let ItemKind::Stripped(kind) = &self.kind { kind } else { &self.kind };
@@ -860,10 +859,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`.
@@ -931,12 +927,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
@@ -979,7 +970,6 @@ impl ItemKind {
             | Self::ProcMacro(_)
             | Self::Primitive(_)
             | Self::AssocConst(..)
-            | Self::RequiredAssocTy(..)
             | Self::AssocTy(..)
             | Self::Stripped(_)
             | Self::Keyword
@@ -2224,18 +2214,21 @@ impl TypeAliasInnerType {
 
 #[derive(Clone, Debug)]
 pub(crate) struct TypeAlias {
-    pub(crate) type_: Type,
     pub(crate) generics: Generics,
+    pub(crate) type_: 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) type_: Option<Type>,
+    // FIXME: Get rid of this somehow!
+    // FIXME(fmease): If `type_` is None this is guaranteed to be None, too! Force this via the type system
+    pub(crate) type_guaranteed_to_come_from_middle: Option<Type>,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]

src/librustdoc/clean/utils.rs

@@ -24,8 +24,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,
 };
@@ -276,10 +276,7 @@ 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 { type_: Some(target), .. }) = &item.kind else { continue };
 
         if let Some(prim) = target.primitive_type() {
             let _prof_timer = tcx.sess.prof.generic_activity("build_primitive_inherent_impls");

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 { type_: Some(_), .. })
             if cache.parent_stack.last().is_some_and(|parent| parent.is_trait_impl()) =>
         {
             // skip associated items in trait impls
             return;
         }
         ItemKind::AssocFn(_, None)
         | ItemKind::AssocConst(clean::AssocConst { rhs: None, .. })
-        | ItemKind::RequiredAssocTy(..)
+        | ItemKind::AssocTy(clean::AssocTy { type_: 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,