Struct TypeRenderer 

pub struct TypeRenderer<'a> { /* private fields */ }

Type renderer for converting rustdoc types to Rust syntax strings.

This struct holds a reference to the crate context and provides methods to render various type constructs into their string representations.

Design Note

The krate field is currently unused because the Type enum is self-contained. However, it is retained for:

• Future-proofing: May need to look up items in krate.index for enhanced rendering
• API consistency: Signals that the renderer is bound to a specific crate context
• Type safety: Prevents accidentally mixing renderers across different crates

Example

let renderer = TypeRenderer::new(&krate);
let type_str = renderer.render_type(&some_type);
let generics = renderer.render_generics(&params);

Implementations

impl<'a> TypeRenderer<'a>

pub const fn new(krate: &'a Crate) -> Self

Create a new type renderer with the given crate context.

Arguments

• krate - The parsed rustdoc crate containing type definitions

pub const fn get_type_id(&self, ty: &Type) -> Option<Id>

Get the ID of a resolved type, if available.

Returns Some(Id) for resolved path types (named types like structs, enums, traits), None for primitives and other type variants.

Arguments

• ty - The type to extract the ID from

pub fn render_type<'t>(&self, ty: &'t Type) -> Cow<'t, str>

Render a rustdoc Type to its Rust syntax string representation.

This is the main entry point for type rendering. It handles all variants of the Type enum and recursively renders nested types.

Arguments

• ty - The type to render

Returns

A Cow<str> representing the type in Rust syntax. Simple types like primitives and generics return borrowed strings to avoid allocation.

Supported Type Variants

• Primitives: u32, bool, str, etc.
• References: &T, &'a mut T
• Pointers: *const T, *mut T
• Slices and arrays: [T], [T; N]
• Tuples: (A, B, C)
• Paths: std::vec::Vec<T>
• Function pointers: fn(A, B) -> C
• Trait objects: dyn Trait + Send
• Impl trait: impl Iterator<Item = T>
• Qualified paths: <T as Trait>::Item

pub fn render_generic_bound<'t>(&self, bound: &'t GenericBound) -> Cow<'t, str>

Render a generic bound (trait bound or lifetime bound).

Examples

• Trait bound: Clone, Iterator<Item = T>
• Modified bound: ?Sized, ~const Drop
• Lifetime bound: 'static, 'a

pub fn render_generics(&self, generics: &[GenericParamDef]) -> String

Render a list of generic parameter definitions.

Produces the <T, U, const N: usize> portion of a signature.

Arguments

• generics - The list of generic parameters from rustdoc

Returns

A string like <T, U> or empty string if no generics.

Filtering

Synthetic parameters (generated by the compiler for impl Trait) are filtered out since they don’t appear in the source.

pub fn render_where_clause(&self, where_predicates: &[WherePredicate]) -> String

Render where clause predicates.

Produces the where T: Clone, U: Send portion of a signature.

Arguments

• where_predicates - The list of where predicates from rustdoc

Returns

A formatted where clause string, or empty string if no predicates.

Format

where
    T: Clone,
    U: Send

pub fn collect_linkable_types(&self, ty: &Type) -> Vec<(String, Id)>

Collect all linkable type names from a type.

This extracts type names that could potentially be linked to their definitions. Returns a set of (ype_name, type_id) pairs for ResolvedPath types.

Linkable Types

• ResolvedPath types (e.g., Vec, HashMap, MyStruct)
• Nested types within generics, references, slices, etc.

Excluded

• Primitives (e.g., u32, bool)
• Generic parameters (e.g., T, U)
• Inferred types (_)

Trait Implementations

impl<'a> Clone for TypeRenderer<'a>

fn clone(&self) -> TypeRenderer<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for TypeRenderer<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Copy for TypeRenderer<'a>