Struct ConditionOptions

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

Used with OnUnimplementedCondition::matches_predicate to evaluate the OnUnimplementedCondition.

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:

ConditionOptions {
    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::traits::ObligationCauseCode.

crate_local: bool

direct: bool

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

generic_args: Vec<(Symbol, String)>

Implementations

impl ConditionOptions

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

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

Trait Implementations

impl Debug for ConditionOptions

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