Enum rustdoc::passes::collect_intra_doc_links::ResolutionFailure

enum ResolutionFailure<'a> {
    WrongNamespace {
        res: Res,
        expected_ns: Namespace,
    },
    NotResolved {
        module_id: DefId,
        partial_res: Option<Res>,
        unresolved: Cow<'a, str>,
    },
    NoParentItem,
    MalformedGenerics(MalformedGenerics),
    Dummy,
}

A link failed to resolve.

Variants

WrongNamespace

This resolved, but with the wrong namespace.

Fields of WrongNamespace

res: Res

What the link resolved to.

expected_ns: Namespace

The expected namespace for the resolution, determined from the link’s disambiguator.

E.g., for [fn@Result] this is Namespace::ValueNS, even though Result’s actual namespace is Namespace::TypeNS.

NotResolved

The link failed to resolve. resolution_failure should look to see if there’s a more helpful error that can be given.

Fields of NotResolved

module_id: DefId

The scope the link was resolved in.

partial_res: Option<Res>

If part of the link resolved, this has the Res.

In [std::io::Error::x], std::io::Error would be a partial resolution.

unresolved: Cow<'a, str>

The remaining unresolved path segments.

In [std::io::Error::x], x would be unresolved.

NoParentItem

This happens when rustdoc can’t determine the parent scope for an item. It is always a bug in rustdoc.

MalformedGenerics(MalformedGenerics)

This link has malformed generic parameters; e.g., the angle brackets are unbalanced.

Dummy

Used to communicate that this should be ignored, but shouldn’t be reported to the user.

This happens when there is no disambiguator and one of the namespaces failed to resolve.

Implementations

impl<'a> ResolutionFailure<'a>

fn full_res(&self) -> Option<Res>

This resolved fully (not just partially) but is erroneous for some other reason

Returns the full resolution of the link, if present.

Trait Implementations

impl<'a> Debug for ResolutionFailure<'a>

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

Formats the value using the given formatter.

impl<'a> From<ResolutionFailure<'a>> for ErrorKind<'a>

fn from(err: ResolutionFailure<'a>) -> Self

Performs the conversion.