Struct rustc_next_trait_solver::solve::Goal

pub struct Goal<I, P>
where
    I: Interner,
{
    pub param_env: <I as Interner>::ParamEnv,
    pub predicate: P,
}

A goal is a statement, i.e. predicate, we want to prove given some assumptions, i.e. param_env.

Most of the time the param_env contains the where-bounds of the function we’re currently typechecking while the predicate is some trait bound.

Fields

param_env: <I as Interner>::ParamEnv

predicate: P

Implementations

impl<I, P> Goal<I, P>

where I: Interner,

pub fn new( cx: I, param_env: <I as Interner>::ParamEnv, predicate: impl Upcast<I, P>, ) -> Goal<I, P>

pub fn with<Q>(self, cx: I, predicate: impl Upcast<I, Q>) -> Goal<I, Q>

Updates the goal to one with a different predicate but the same param_env.

Trait Implementations

impl<I, P> Clone for Goal<I, P>

where I: Interner, P: Clone,

fn clone(&self) -> Goal<I, P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I, P> Debug for Goal<I, P>

where I: Interner, P: Debug,

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

Formats the value using the given formatter.

impl<I, P, __D> Decodable<__D> for Goal<I, P>

where I: Interner, __D: TyDecoder<I = I>, <I as Interner>::ParamEnv: Decodable<__D>, P: Decodable<__D>,

fn decode(__decoder: &mut __D) -> Goal<I, P>

impl<I, P, __E> Encodable<__E> for Goal<I, P>

where I: Interner, __E: TyEncoder<I = I>, <I as Interner>::ParamEnv: Encodable<__E>, P: Encodable<__E>,

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

impl<I, P> Hash for Goal<I, P>

where I: Interner, P: Hash,

fn hash<__HIP>(&self, __state: &mut __HIP)

where __HIP: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<I, P, __CTX> HashStable<__CTX> for Goal<I, P>

where I: Interner, <I as Interner>::ParamEnv: HashStable<__CTX>, P: HashStable<__CTX>,

fn hash_stable( &self, __hcx: &mut __CTX, __hasher: &mut StableHasher<SipHasher128>, )

impl<I, P, J> Lift<J> for Goal<I, P>

where I: Interner, J: Interner, <I as Interner>::ParamEnv: Lift<J, Lifted = <J as Interner>::ParamEnv>, P: Lift<J, Lifted = P>,

type Lifted = Goal<J, P>

fn lift_to_interner(self, interner: J) -> Option<Goal<J, P>>

impl<I, P> PartialEq for Goal<I, P>

where I: Interner, P: PartialEq,

fn eq(&self, other: &Goal<I, P>) -> 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<I, P> TypeFoldable<I> for Goal<I, P>

where I: Interner, <I as Interner>::ParamEnv: TypeFoldable<I>, P: TypeFoldable<I>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<Goal<I, P>, <__F as FallibleTypeFolder<I>>::Error>

where __F: FallibleTypeFolder<I>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Self

where F: TypeFolder<I>,

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.

impl<I, P> TypeVisitable<I> for Goal<I, P>

where I: Interner, <I as Interner>::ParamEnv: TypeVisitable<I>, P: TypeVisitable<I>,

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<I>>::Result

where __V: TypeVisitor<I>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<I, P> Copy for Goal<I, P>

where I: Interner, P: Copy,

impl<I, P> Eq for Goal<I, P>

where I: Interner, P: Eq,

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.