Enum QueryErr 

pub enum QueryErr {
    Unsupported {
        def_id: DefId,
        err: UnsupportedErr,
    },
    Ignored {
        def_id: DefId,
    },
    InvalidGenericArg {
        def_id: DefId,
    },
    MissingAssocReft {
        impl_id: DefId,
        trait_id: DefId,
        name: Symbol,
    },
    OpaqueStruct {
        struct_id: DefId,
    },
    Bug {
        def_id: Option<DefId>,
        location: String,
        msg: String,
    },
    Emitted(ErrorGuaranteed),
}

An error produced by a query.

We make a distinction between errors reported at def-site and errors reported at use-site.

For most errors reported at the def-site of an item, it makes little sense to check the definition of dependent items. For example, if a function signature is ill-formed, checking the body of another function that calls it, can produce confusing errors. In some cases, we can even fail to produce a signature for a function in which case we can’t even check its call sites. For these cases, we emit an error at the definition site and return a QueryErr::Emitted. When checking a dependent, we detect this and early return without reporting any errors at the use-site.

Other errors are better reported at the use-site. For example, if some code calls a function from an external crate that has unsupported features, we ought to report the error at the call-site, because it would be confusing to only mention the definition of the external function without showing which part of the code is calling it. To attach a span to an error one can use QueryErr::at to get a QueryErrAt.

Both QueryErr and QueryErrAt implement [Diagnostic]. The implementation for QueryErr reports the error at the definition site, while the implementation for QueryErrAt reports it at the (attached) use-site span. This allows us to play a bit lose because we can emit an error without attaching a span, but this means we may forget to attach spans at some places. We should consider not implementing [Diagnostic] for QueryErr such that we always make the distinction between use-site and def-site explicit, e.g., we could have methods QueryErr::at_use_site and QueryErr::at_def_site returning types with different implementations of [Diagnostic].

Variants

Unsupported

Fields

def_id: DefId

err: UnsupportedErr

Ignored

Fields

def_id: DefId

InvalidGenericArg

Fields

def_id: DefId

MissingAssocReft

Fields

impl_id: DefId

trait_id: DefId

name: Symbol

OpaqueStruct

An operation tried to access the internals of an opaque struct.

Fields

struct_id: DefId

Bug

Used to report bugs, typically this means executing an arm in a match we thought it was unreachable. Use this instead of panicking if it is easy to return a QueryErr. Use QueryErr::bug or crate::query_bug! to construct this variant to track source location.

Fields

def_id: Option<DefId>

location: String

msg: String

Emitted(ErrorGuaranteed)

Implementations

impl QueryErr

pub fn unsupported(def_id: DefId, err: UnsupportedErr) -> Self

pub fn bug(def_id: Option<DefId>, msg: impl ToString) -> Self

pub fn at(self, cx: impl Into<ErrCtxt>) -> QueryErrAt

Trait Implementations

impl Clone for QueryErr

fn clone(&self) -> QueryErr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QueryErr

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

Formats the value using the given formatter.

impl<__D: SpanDecoder> Decodable<__D> for QueryErr

fn decode(__decoder: &mut __D) -> Self

impl<'a> Diagnostic<'a> for QueryErr

fn into_diag( self, dcx: DiagCtxtHandle<'a>, _level: Level, ) -> Diag<'a, ErrorGuaranteed>

Write out as a diagnostic out of DiagCtxt.

impl<__E: SpanEncoder> Encodable<__E> for QueryErr

fn encode(&self, __encoder: &mut __E)

impl From<ErrorGuaranteed> for QueryErr

fn from(err: ErrorGuaranteed) -> Self

Converts to this type from the input type.