Struct FilterOptions 

pub struct FilterOptions {
    pub self_types: Vec<String>,
    pub from_desugaring: Option<DesugaringKind>,
    pub cause: Option<String>,
    pub crate_local: bool,
    pub direct: bool,
    pub generic_args: Vec<(Symbol, String)>,
}

Used with Filter::matches_predicate to evaluate the Filter.

For example, given a

#[rustc_on_unimplemented(
    on(all(from_desugaring = "QuestionMark"),
        message = "the `?` operator can only be used in {ItemContext} \
                    that returns `Result` or `Option` \
                    (or another type that implements `{FromResidual}`)",
        label = "cannot use the `?` operator in {ItemContext} that returns `{Self}`",
        parent_label = "this function should return `Result` or `Option` to accept `?`"
    ),
)]
pub trait FromResidual<R = <Self as Try>::Residual> {
   ...
}

async fn an_async_function() -> u32 {
    let x: Option<u32> = None;
    x?; //~ ERROR the `?` operator
    22
}

it will look like this:

FilterOptions {
    self_types: ["u32", "{integral}"],
    from_desugaring: Some("QuestionMark"),
    cause: None,
    crate_local: false,
    direct: true,
    generic_args: [("Self","u32"),
        ("R", "core::option::Option<core::convert::Infallible>"),
        ("R", "core::option::Option<T>" ),
    ],
}

Fields

self_types: Vec<String>

All the self types that may apply.

from_desugaring: Option<DesugaringKind>

cause: Option<String>

Match on a variant of rustc_infer’s ObligationCauseCode.

crate_local: bool

direct: bool

Is the obligation “directly” user-specified, rather than derived?

generic_args: Vec<(Symbol, String)>

Implementations

impl FilterOptions

pub fn has_flag(&self, name: Flag) -> bool

pub fn contains(&self, name: Name, value: String) -> bool

Trait Implementations

impl Debug for FilterOptions

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

Formats the value using the given formatter.

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: 80 bytes