Struct rustdoc::passes::collect_intra_doc_links::LinkCollector
source · struct LinkCollector<'a, 'tcx> {
cx: &'a mut DocContext<'tcx>,
mod_ids: Vec<DefId>,
visited_links: FxHashMap<ResolutionInfo, Option<(Res, Option<UrlFragment>)>>,
}
Fields
cx: &'a mut DocContext<'tcx>
mod_ids: Vec<DefId>
A stack of modules used to decide what scope to resolve in.
The last module will be used if the parent scope of the current item is unknown.
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).
Implementations
sourceimpl<'a, 'tcx> LinkCollector<'a, 'tcx>
impl<'a, 'tcx> LinkCollector<'a, 'tcx>
sourcefn variant_field<'path>(
&self,
path_str: &'path str,
item_id: ItemId,
module_id: DefId
) -> Result<(Res, DefId), UnresolvedPath<'path>>
fn variant_field<'path>(
&self,
path_str: &'path str,
item_id: ItemId,
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.
sourcefn resolve_primitive_associated_item(
&self,
prim_ty: PrimitiveType,
ns: Namespace,
item_name: Symbol
) -> Option<(Res, DefId)>
fn resolve_primitive_associated_item(
&self,
prim_ty: PrimitiveType,
ns: Namespace,
item_name: Symbol
) -> Option<(Res, DefId)>
Given a primitive type, try to resolve an associated item.
fn resolve_self_ty(
&self,
path_str: &str,
ns: Namespace,
item_id: ItemId
) -> Option<Res>
sourcefn resolve_path(
&self,
path_str: &str,
ns: Namespace,
item_id: ItemId,
module_id: DefId
) -> Option<Res>
fn resolve_path(
&self,
path_str: &str,
ns: Namespace,
item_id: ItemId,
module_id: DefId
) -> Option<Res>
Convenience wrapper around resolve_rustdoc_path
.
This also handles resolving true
and false
as booleans.
NOTE: resolve_rustdoc_path
knows only about paths, not about types.
Associated items will never be resolved by this function.
sourcefn resolve<'path>(
&mut self,
path_str: &'path str,
ns: Namespace,
item_id: ItemId,
module_id: DefId
) -> Result<(Res, Option<DefId>), UnresolvedPath<'path>>
fn resolve<'path>(
&mut self,
path_str: &'path str,
ns: Namespace,
item_id: ItemId,
module_id: DefId
) -> Result<(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.
sourcefn def_id_to_res(&self, ty_id: DefId) -> Option<Res>
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.
sourcefn primitive_type_to_ty(&mut self, prim: PrimitiveType) -> Option<Ty<'tcx>>
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
sourceimpl LinkCollector<'_, '_>
impl LinkCollector<'_, '_>
sourcefn resolve_link(
&mut self,
item: &Item,
dox: &str,
parent_node: Option<DefId>,
link: &PreprocessedMarkdownLink
) -> Option<ItemLink>
fn resolve_link(
&mut self,
item: &Item,
dox: &str,
parent_node: Option<DefId>,
link: &PreprocessedMarkdownLink
) -> Option<ItemLink>
This is the entry point for resolving an intra-doc link.
FIXME(jynelson): this is way too many arguments
fn verify_disambiguator(
&self,
path_str: &str,
ori_link: &MarkdownLink,
kind: DefKind,
id: DefId,
disambiguator: Option<Disambiguator>,
item: &Item,
diag_info: &DiagnosticInfo<'_>
) -> Option<()>
fn report_disambiguator_mismatch(
&self,
path_str: &str,
ori_link: &MarkdownLink,
specified: Disambiguator,
resolved: Res,
diag_info: &DiagnosticInfo<'_>
)
fn report_rawptr_assoc_feature_gate(
&self,
dox: &str,
ori_link: &MarkdownLink,
item: &Item
)
fn resolve_with_disambiguator_cached(
&mut self,
key: ResolutionInfo,
diag: DiagnosticInfo<'_>,
cache_errors: bool
) -> Option<(Res, Option<UrlFragment>)>
sourcefn resolve_with_disambiguator(
&mut self,
key: &ResolutionInfo,
diag: DiagnosticInfo<'_>
) -> Option<(Res, Option<DefId>)>
fn resolve_with_disambiguator(
&mut self,
key: &ResolutionInfo,
diag: DiagnosticInfo<'_>
) -> Option<(Res, Option<DefId>)>
After parsing the disambiguator, resolve the main part of the link.
Trait Implementations
sourceimpl<'a, 'tcx> DocVisitor for LinkCollector<'a, 'tcx>
impl<'a, 'tcx> DocVisitor for LinkCollector<'a, 'tcx>
fn visit_item(&mut self, item: &Item)
sourcefn visit_inner_recur(&mut self, kind: &ItemKind)
fn visit_inner_recur(&mut self, kind: &ItemKind)
sourcefn visit_item_recur(&mut self, item: &Item)
fn visit_item_recur(&mut self, item: &Item)
fn visit_mod(&mut self, m: &Module)
fn visit_crate(&mut self, c: &Crate)
Auto Trait Implementations
impl<'a, 'tcx> !RefUnwindSafe for LinkCollector<'a, 'tcx>
impl<'a, 'tcx> !Send for LinkCollector<'a, 'tcx>
impl<'a, 'tcx> !Sync for LinkCollector<'a, 'tcx>
impl<'a, 'tcx> Unpin for LinkCollector<'a, 'tcx>where
'tcx: 'a,
impl<'a, 'tcx> !UnwindSafe for LinkCollector<'a, 'tcx>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
impl<V, T> VZip<V> for Twhere
V: MultiLane<T>,
impl<V, T> VZip<V> for Twhere
V: MultiLane<T>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,
sourcefn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
impl<'a, T> Captures<'a> for Twhere
T: ?Sized,
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: 64 bytes