Struct LinkCollector

pub(crate) struct LinkCollector<'a, 'tcx> {
    pub(crate) cx: &'a mut DocContext<'tcx>,
    pub(crate) visited_links: FxHashMap<ResolutionInfo, Option<(Res, Option<UrlFragment>)>>,
    pub(crate) ambiguous_links: FxIndexMap<(ItemId, String), Vec<AmbiguousLinks>>,
}

Fields

cx: &'a mut DocContext<'tcx>

visited_links: FxHashMap<ResolutionInfo, Option<(Res, Option<UrlFragment>)>>

Cache the resolved links so we can avoid resolving (and emitting errors for) the same link. The link will be None if it could not be resolved (i.e. the error was cached).

ambiguous_links: FxIndexMap<(ItemId, String), Vec<AmbiguousLinks>>

According to rustc_resolve, these links are ambiguous.

However, we cannot link to an item that has been stripped from the documentation. If all but one of the “possibilities” are stripped, then there is no real ambiguity. To determine if an ambiguity is real, we delay resolving them until after Cache::populate, then filter every item that doesn’t have a cached path.

We could get correct results by simply delaying everything. This would have fewer happy codepaths, but we want to distinguish different kinds of error conditions, and this is easy to do by resolving links as soon as possible.

Implementations

impl<'tcx> LinkCollector<'_, 'tcx>

fn variant_field<'path>( &self, path_str: &'path str, item_id: DefId, module_id: DefId, ) -> Result<(Res, DefId), UnresolvedPath<'path>>

Given a full link, parse it as an enum struct variant.

In particular, this will return an error whenever there aren’t three full path segments left in the link.

fn resolve_primitive_associated_item( &self, prim_ty: PrimitiveType, ns: Namespace, item_name: Symbol, ) -> Vec<(Res, DefId)>

Given a primitive type, try to resolve an associated item.

fn resolve_self_ty( &self, path_str: &str, ns: Namespace, item_id: DefId, ) -> Option<Res>

fn resolve_path( &self, path_str: &str, ns: Namespace, item_id: DefId, module_id: DefId, ) -> Option<Res>

Convenience wrapper around doc_link_resolutions.

This also handles resolving true and false as booleans. NOTE: doc_link_resolutions knows only about paths, not about types. Associated items will never be resolved by this function.

fn resolve<'path>( &mut self, path_str: &'path str, ns: Namespace, disambiguator: Option<Disambiguator>, item_id: DefId, module_id: DefId, ) -> Result<Vec<(Res, Option<DefId>)>, UnresolvedPath<'path>>

Resolves a string as a path within a particular namespace. Returns an optional URL fragment in the case of variants and methods.

fn def_id_to_res(&self, ty_id: DefId) -> Option<Res>

Convert a DefId to a Res, where possible.

This is used for resolving type aliases.

fn primitive_type_to_ty(&mut self, prim: PrimitiveType) -> Option<Ty<'tcx>>

Convert a PrimitiveType to a Ty, where possible.

This is used for resolving trait impls for primitives

fn resolve_associated_item( &mut self, root_res: Res, item_name: Symbol, ns: Namespace, disambiguator: Option<Disambiguator>, module_id: DefId, ) -> Vec<(Res, DefId)>

Resolve an associated item, returning its containing page’s Res and the fragment targeting the associated item on its page.

impl LinkCollector<'_, '_>

fn resolve_links(&mut self, item: &Item)

pub(crate) fn save_link(&mut self, item_id: ItemId, link: ItemLink)

fn resolve_link( &mut self, dox: &String, item: &Item, item_id: DefId, module_id: DefId, PreprocessedMarkdownLink: &PreprocessedMarkdownLink, ) -> Option<ItemLink>

This is the entry point for resolving an intra-doc link.

FIXME(jynelson): this is way too many arguments

fn validate_link(&self, original_did: DefId) -> bool

Returns true if a link could be generated from the given intra-doc information.

This is a very light version of format::href_with_root_path since we’re only interested about whether we can generate a link to an item or not.

• If original_did is local, then we check if the item is reexported or public.
• If original_did is not local, then we check if the crate it comes from is a direct public dependency.

pub(crate) fn resolve_ambiguities(&mut self)

fn compute_link( &mut self, res: Res, fragment: Option<UrlFragment>, path_str: &str, disambiguator: Option<Disambiguator>, diag_info: DiagnosticInfo<'_>, link_text: &Box<str>, ) -> Option<ItemLink>

fn verify_disambiguator( &self, path_str: &str, kind: DefKind, id: DefId, disambiguator: Option<Disambiguator>, diag_info: &DiagnosticInfo<'_>, ) -> Option<()>

fn report_disambiguator_mismatch( &self, path_str: &str, specified: Disambiguator, resolved: Res, diag_info: &DiagnosticInfo<'_>, )

fn report_rawptr_assoc_feature_gate( &self, dox: &str, ori_link: &MarkdownLinkRange, item: &Item, )

fn resolve_with_disambiguator_cached( &mut self, key: ResolutionInfo, diag: DiagnosticInfo<'_>, cache_errors: bool, ) -> Option<Vec<(Res, Option<UrlFragment>)>>

fn resolve_with_disambiguator( &mut self, key: &ResolutionInfo, diag: DiagnosticInfo<'_>, ) -> Vec<(Res, Option<DefId>)>

After parsing the disambiguator, resolve the main part of the link.

Trait Implementations

impl DocVisitor<'_> for LinkCollector<'_, '_>

fn visit_item(&mut self, item: &Item)

fn visit_inner_recur(&mut self, kind: &'a ItemKind)

Don’t override!

fn visit_item_recur(&mut self, item: &'a Item)

Don’t override!

fn visit_mod(&mut self, m: &'a Module)

fn visit_crate(&mut self, c: &'a Crate)

This is the main entrypoint of DocVisitor.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 96 bytes