Struct rustc_infer::traits::solve::Goal

pub struct Goal<'tcx, P> {
    pub predicate: P,
    pub param_env: ParamEnv<'tcx>,
}

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

predicate: P

param_env: ParamEnv<'tcx>

Implementations

impl<'tcx, P> Goal<'tcx, P>

pub fn new( tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, predicate: impl ToPredicate<'tcx, P> ) -> Goal<'tcx, P>

pub fn with<Q>( self, tcx: TyCtxt<'tcx>, predicate: impl ToPredicate<'tcx, Q> ) -> Goal<'tcx, Q>

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

Trait Implementations

impl<'tcx, P> Clone for Goal<'tcx, P>

where P: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx, P> Debug for Goal<'tcx, P>

where P: Debug,

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

Formats the value using the given formatter.

impl<'tcx, P> From<Obligation<'tcx, P>> for Goal<'tcx, P>

fn from(value: Obligation<'tcx, P>) -> Self

Converts to this type from the input type.

impl<'tcx, P> Hash for Goal<'tcx, P>

where P: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: 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<'tcx, '__ctx, P> HashStable<StableHashingContext<'__ctx>> for Goal<'tcx, P>

where P: HashStable<StableHashingContext<'__ctx>>,

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher )

impl<'tcx, P> PartialEq for Goal<'tcx, P>

where P: PartialEq,

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

where P: TypeFoldable<TyCtxt<'tcx>>,

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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<'tcx, P> TypeVisitable<TyCtxt<'tcx>> for Goal<'tcx, P>

where P: TypeVisitable<TyCtxt<'tcx>>,

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

where __V: TypeVisitor<TyCtxt<'tcx>>,

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

impl<'tcx, P> Copy for Goal<'tcx, P>

where P: Copy,

impl<'tcx, P> Eq for Goal<'tcx, P>

where P: Eq,

impl<'tcx, P> StructuralPartialEq for Goal<'tcx, P>

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.