Struct Unnormalized 

pub struct Unnormalized<I: Interner, T> {
    value: T,
    _tcx: PhantomData<fn() -> I>,
}

A wrapper for values that need normalization.

FIXME(#155345): This is very WIP. The plan is to replace the skip_norm_wip spread throughout the codebase with proper normalization. This is the first step toward switching to eager normalization with the next solver. See the normalization refactor plan here.

We’re in a weird intermediate state as the change is too big to land in a single PR. While this work is in progress, just use Unnormalized::new_wip and Unnormalized::skip_norm_wip as needed.

The interner type parameter exists to constraint generic for certain impl, e.g., Unnormalized<I, I::Clause>.

Fields

value: T

_tcx: PhantomData<fn() -> I>

Implementations

impl<I: Interner, T> Unnormalized<I, T>

pub fn new(value: T) -> Unnormalized<I, T>

Should only be used in limited situations where you produce an potentially unnormalized value, like in (Early)Binder/GenericPredicates instantiation.

pub fn new_wip(value: T) -> Unnormalized<I, T>

FIXME: This is going to be eventually removed once we migrate the relevant APIs to return Unnormalized.

pub fn skip_normalization(self) -> T

Intentionally skip normalization. You probably should perform normalization in most cases.

pub fn skip_norm_wip(self) -> T

FIXME: This is going to be eventually removed. If you meet this in codebase, try using one of the normalization routines to consume the Unnormalized wrapper. Or use skip_normalization when normalization is really unnecessary.

pub fn map<F, U>(self, f: F) -> Unnormalized<I, U>

where F: FnOnce(T) -> U,

pub fn as_ref(&self) -> Unnormalized<I, &T>

pub fn map_ref<U, F>(&self, f: F) -> Unnormalized<I, U>

where F: FnOnce(&T) -> U,

impl<I: Interner, T, U> Unnormalized<I, (T, U)>

pub fn unzip(self) -> (Unnormalized<I, T>, Unnormalized<I, U>)

impl<I: Interner, T> Unnormalized<I, Binder<I, T>>

pub fn skip_binder(self) -> T

impl<I: Interner> Unnormalized<I, I::Clause>

pub fn as_trait_clause( self, ) -> Option<Unnormalized<I, Binder<I, TraitPredicate<I>>>>

pub fn kind(self) -> Unnormalized<I, Binder<I, ClauseKind<I>>>

impl<I: Interner> Unnormalized<I, Binder<I, TraitPredicate<I>>>

pub fn self_ty(self) -> Unnormalized<I, Binder<I, I::Ty>>

pub fn def_id(self) -> I::TraitId

pub fn polarity(self) -> PredicatePolarity

impl<I: Interner> Unnormalized<I, Binder<I, TraitRef<I>>>

pub fn self_ty(&self) -> Unnormalized<I, Binder<I, I::Ty>>

pub fn def_id(&self) -> I::TraitId

pub fn to_host_effect_clause( self, cx: I, constness: BoundConstness, ) -> Unnormalized<I, I::Clause>

Trait Implementations

impl<I: Interner, T> Clone for Unnormalized<I, T>

where T: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Interner, T> Debug for Unnormalized<I, T>

where T: Debug,

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

Formats the value using the given formatter.

impl<I: Interner, T> PartialEq for Unnormalized<I, T>

where T: PartialEq,

fn eq(&self, __other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<I: Interner, T> PartialOrd for Unnormalized<I, T>

where T: PartialOrd,

fn partial_cmp(&self, __other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<I: Interner, T> Copy for Unnormalized<I, T>

where T: Copy,

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.