Struct Resolver 

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

A navigation engine over a Navigator.

Construct one per query (e.g. one per top-level command in a Request). The frame stack drains to empty between top-level methods, so a single Resolver is reusable across many lookups in the same operation.

Methods that walk through items take &mut self because resolution mutates the frame stack. Returned DocRefs borrow from the underlying Navigator, so they outlive the Resolver.

Implementations

impl<'a> Resolver<'a>

pub fn new(navigator: &'a Navigator) -> Self

pub fn navigator(&self) -> &'a Navigator

pub fn current_path(&self) -> impl Iterator<Item = &str> + '_

Segments traversed in the current resolution chain. Empty between top-level calls.

impl<'a> Resolver<'a>

pub fn resolve_path( &mut self, path: &str, suggestions: &mut Vec<Suggestion<'a>>, ) -> Option<DocRef<'a, Item>>

Resolve a path like "std::vec::Vec" or "tokio@1::runtime::Runtime".

Primary string entrypoint for any user-supplied crate or item path.

impl<'a> Resolver<'a>

pub fn find_child( &mut self, parent: DocRef<'a, Item>, target: &str, ) -> Option<DocRef<'a, Item>>

Find a child of parent named target. Used for single-segment lookups (e.g. walking item_summary.path to wire up “Defined at” links).

pub fn find_by_path<'s>( &mut self, parent: DocRef<'a, Item>, segments: impl IntoIterator<Item = &'s str>, ) -> Option<DocRef<'a, Item>>

Walk a sequence of name segments from parent.

impl<'a> Resolver<'a>

pub fn follow_use( &mut self, use_item: DocRef<'a, Use>, parent_module: DocRef<'a, Item>, ) -> Option<DocRef<'a, Item>>

Resolve a Use to its target item. Tries use_item.id first (cheap local lookup, can’t cycle); on miss, falls back to resolving the source path string against the parent module’s path.

parent_module is the module containing the Use, used to resolve self::/super:: prefixes in the source string.

pub fn resolve_lazy_child( &mut self, child: LazyChild<'a>, ) -> Option<DocRef<'a, Item>>

Resolve a LazyChild to a concrete item. For non-glob Uses, the imported name is preserved on the returned DocRef.

impl<'a> Resolver<'a>

pub fn children(&mut self, item: DocRef<'a, Item>) -> Vec<DocRef<'a, Item>>

Children of item with Uses resolved and globs expanded. Equivalent to the old item.child_items().

pub fn children_including_uses( &mut self, item: DocRef<'a, Item>, ) -> Vec<DocRef<'a, Item>>

Children of item, but yield Use items themselves rather than their targets. Used by the search indexer to record use statements.

pub fn ids( &mut self, parent: DocRef<'a, Item>, ids: &'a [Id], ) -> Vec<DocRef<'a, Item>>

Resolve a slice of Ids in parent, expanding Use items. Replaces the old id_iter.

pub fn ids_including_uses( &mut self, parent: DocRef<'a, Item>, ids: &'a [Id], ) -> Vec<DocRef<'a, Item>>

Like Self::ids but yields Use items themselves instead of their targets.

impl<'a> Resolver<'a>

pub fn get_path( &mut self, origin: DocRef<'a, Item>, id: Id, ) -> Option<DocRef<'a, Item>>

Resolve an Id from origin’s crate to a DocRef. The id is looked up in origin’s rustdoc paths map; for external-crate ids this crosses the crate boundary, loading the target crate if needed and walking its public path.

pub fn get_item_from_id_path( &mut self, crate_name: &str, ids: &[u32], ) -> Option<(DocRef<'a, Item>, Vec<&'a str>)>

Get an item from a sequence of Ids starting at the named crate’s root. Returns the resolved item plus the path of segment names.