Enum clippy_utils::ty::type_certainty::certainty::Certainty

pub enum Certainty {
    Uncertain,
    Certain(Option<DefId>),
    Contradiction,
}

Variants

Uncertain

Determining the type requires contextual information.

Certain(Option<DefId>)

The type can be determined purely from subexpressions. If the argument is Some(..), the specific DefId is known. Such arguments are needed to handle path segments whose res is Res::Err.

Contradiction

The heuristic believes that more than one DefId applies to a type—this is a bug.

Implementations

impl Certainty

pub fn join(self, other: Self) -> Self

Join two Certaintys preserving their DefIds (if any). Generally speaking, this method should be used only when self and other refer directly to types. Otherwise, join_clearing_def_ids should be used.

pub fn join_clearing_def_ids(self, other: Self) -> Self

Join two Certaintys after clearing their DefIds. This method should be used when self or other do not necessarily refer to types, e.g., when they are aggregations of other Certaintys.

pub fn clear_def_id(self) -> Certainty

pub fn with_def_id(self, def_id: DefId) -> Certainty

pub fn to_def_id(self) -> Option<DefId>

pub fn is_certain(self) -> bool

Trait Implementations

impl Clone for Certainty

fn clone(&self) -> Certainty

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Certainty

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

Formats the value using the given formatter.

impl Meet for Certainty

fn meet(self, other: Self) -> Self

impl PartialEq for Certainty

fn eq(&self, other: &Certainty) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Certainty

impl Eq for Certainty

impl StructuralPartialEq for Certainty

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

Size for each variant:

• Uncertain: 0 bytes
• Certain: 8 bytes
• Contradiction: 0 bytes