Struct ImplUtils 

pub struct ImplUtils;

Utility functions to work with impl’s and generics

Implementations

impl ImplUtils

pub fn is_trivial_derive_impl(impl_block: &Impl) -> bool

Check if an impl block is for a trivial derive trait.

Returns true if the impl is for one of the commonly derived traits (Clone, Copy, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord).

Examples

use rustdoc_types::Impl;
// For an impl block with trait "Clone", returns true
// For an impl block with trait "Display", returns false

pub fn get_trivial_derive_description(trait_name: &str) -> Option<&'static str>

Get the description for a trivial derive trait.

Returns None if the trait is not in the trivial derives list.

pub fn is_blanket_impl(impl_block: &Impl) -> bool

Check if an impl block is for a blanket trait that should be filtered.

Returns true if the impl is for one of the commonly auto-derived traits that add noise to documentation (From, Into, Any, Borrow, etc.).

pub fn is_generic_type(ty: &Type) -> bool

Check if a type is generic (contains a type parameter like T).

This is used to determine whether to show generic parameters in impl blocks. For blanket impls like impl<T> Trait for T, we only show the generics if the for_ type is actually generic. When the impl is instantiated for a concrete type like TocEntry, we hide the generics.

Examples

// Generic type - returns true
is_generic_type(&Type::Generic("T")) == true

// Concrete type - returns false
is_generic_type(&Type::ResolvedPath { name: "TocEntry", .. }) == false

// Container with generic - returns true
is_generic_type(&Type::ResolvedPath {
    name: "Vec",
    args: Some(GenericArgs::AngleBracketed { args: [Type::Generic("T")] })
}) == true

pub fn extract_impl_signature_generics(impl_block: &Impl) -> HashSet<String>

Extract generic parameter names that appear in the impl signature (for_ and trait).

This extracts generics from only the visible parts of the impl header:

1. The for_ type: impl<T> Trait for Foo<T> → extracts T from Foo<T>
2. The trait path: impl<U> Trait<U> for Foo → extracts U from Trait<U>

Unlike [extract_impl_visible_generics], this does NOT extract from where clauses. Use this for rendering purposes when deciding which generic params to show in impl<...>. Generics that only appear in where clauses should not be shown in the impl header since the where clause itself is not rendered.

Examples

impl<T: Sized> IntoEither for T
  └─ for_ type is Generic("T") → extracts ["T"]
  └─ When rendered for `Either<L, R>`, for_ becomes `Either<L, R>`
  └─ Extracts ["L", "R"], NOT ["T"]
  └─ T is only in where clause, so `impl<T>` should NOT be shown

impl<T> Clone for Wrapper<T>
  └─ for_ type has `Wrapper<T>` → extracts ["T"]
  └─ Result: render as `impl<T>`

impl<T, U> Trait<U> for Foo<T>
  └─ for_ type has `Foo<T>` → extracts ["T"]
  └─ trait path has `Trait<U>` → extracts ["U"]
  └─ Result: render as `impl<T, U>` (both visible)

pub fn extract_impl_visible_generics(impl_block: &Impl) -> HashSet<String>

Extract all generic parameter names visible in an impl block’s signature.

Why This Is Needed

Rustdoc JSON stores impl generics in two places that can have DIFFERENT names:

• impl_block.generics.params - the declared params (e.g., T from impl<T>)
• impl_block.for_ - the actual type (e.g., StyledObject<D>)

For blanket impls, these names often differ! The compiler transforms:

impl<D: Display> ToString for StyledObject<D>

Into JSON where generics.params has T but for_ has StyledObject<D>. If we blindly use generics.params, we’d render impl<T> ToString for StyledObject<D>.

Solution

Extract generics from what’s VISIBLE in the signature:

1. The for_ type: Foo<T> → extracts T
2. The trait path: Iterator<Item = U> → extracts U
3. Where clauses: where T: Clone → extracts T

Then filter generics.params to only include names that appear in visible locations.

Note: For rendering the impl header, use [extract_impl_signature_generics] instead, which excludes where clause generics.

Examples

impl<T> Clone for Wrapper<T>
  └─ for_ type has `Wrapper<T>` → extracts ["T"]
  └─ Result: render as `impl<T>`

impl<T, U> Trait<U> for Foo<T> where T: Clone
  └─ for_ type has `Foo<T>` → extracts ["T"]
  └─ trait path has `Trait<U>` → extracts ["U"]
  └─ where clause has `T: Clone` → extracts ["T"]
  └─ Result: render as `impl<T, U>` (both visible)

impl<D: Display> ToString for StyledObject<D>
  └─ for_ type has `StyledObject<D>` → extracts ["D"]
  └─ Result: render as `impl<D>` (not `impl<T>`)

pub fn has_hidden_generic_refs(impl_block: &Impl, krate: &Crate) -> bool

Check if an impl has associated types referencing generics NOT visible in the signature.

The Problem

Some impl blocks have generics that only appear in associated types, not in the visible signature. When rendered, this produces confusing output:

impl DoubleEndedIterator for Foo    ← No `I` visible!
    type Item = <I as Iterator>::Item   ← Where does `I` come from?

Detection Strategy

1. Extract “visible” generics from: for_ type, trait path, where clause
2. Extract “declared” generics from: impl_block.generics.params
3. Compute “hidden” = declared - visible
4. Check if any associated type references a hidden generic

Examples

// FILTER THIS - `I` is hidden but used in associated type
impl<I: Iterator> DoubleEndedIterator for Foo {
    type Item = <I as Iterator>::Item;
}
visible = {}        (Foo has no generics)
declared = {I}      (from impl<I>)
hidden = {I}        (declared - visible)
assoc type uses I   → FILTER!

// KEEP THIS - `T` is visible in for_ type
impl<T> Iterator for Wrapper<T> {
    type Item = T;
}
visible = {T}       (from Wrapper<T>)
declared = {T}      (from impl<T>)
hidden = {}         (all visible)
→ KEEP!

// KEEP THIS - `U` is visible in trait path
impl<T, U> Trait<U> for Foo<T> {
    type Output = (T, U);
}
visible = {T, U}    (T from Foo<T>, U from Trait<U>)
declared = {T, U}   (from impl<T, U>)
hidden = {}         (all visible)
→ KEEP!